diff --git a/p2p/crypto/key.go b/p2p/crypto/key.go index f360fbd0660bcb8aea128c640b077efd9e879d5d..940effba11fd29bf5205a747e7730bb058bb89b5 100644 --- a/p2p/crypto/key.go +++ b/p2p/crypto/key.go @@ -21,7 +21,7 @@ import ( pb "github.com/ipfs/go-libp2p/p2p/crypto/pb" - proto "github.com/gogo/protobuf/proto" + proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" u "util" diff --git a/p2p/crypto/pb/crypto.pb.go b/p2p/crypto/pb/crypto.pb.go index f6001ff968ae2556f41d5bf1a5a7a781a7483bc4..35249589c6e3ac0457dcf0d1ca3f73ba187543af 100644 --- a/p2p/crypto/pb/crypto.pb.go +++ b/p2p/crypto/pb/crypto.pb.go @@ -14,7 +14,7 @@ It has these top-level messages: */ package crypto_pb -import proto "github.com/gogo/protobuf/proto" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" import math "math" // Reference imports to suppress errors if they are not otherwise used. diff --git a/p2p/crypto/rsa.go b/p2p/crypto/rsa.go index 32bbbfbd3068be9363b546a26eed4b5d437e9052..acd3f2809eef59516c102195ea861ec860e66ed6 100644 --- a/p2p/crypto/rsa.go +++ b/p2p/crypto/rsa.go @@ -8,7 +8,7 @@ import ( "crypto/x509" "errors" - proto "github.com/gogo/protobuf/proto" + proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" pb "github.com/ipfs/go-libp2p/p2p/crypto/pb" ) diff --git a/p2p/crypto/secio/pb/spipe.pb.go b/p2p/crypto/secio/pb/spipe.pb.go index 0b4919b828a4837b5167d36f7d17b53dddcaa724..e3a656e1dd190babbc8c053015fdd51b40d8d6ab 100644 --- a/p2p/crypto/secio/pb/spipe.pb.go +++ b/p2p/crypto/secio/pb/spipe.pb.go @@ -14,7 +14,7 @@ It has these top-level messages: */ package spipe_pb -import proto "github.com/gogo/protobuf/proto" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" import math "math" // Reference imports to suppress errors if they are not otherwise used. diff --git a/p2p/crypto/secio/rw.go b/p2p/crypto/secio/rw.go index f01d63e64f4e3e8abb671c87c6c88fb93dd7f68d..e5c297b3ed0c82ffa52edfcb7d59a63c79e6678e 100644 --- a/p2p/crypto/secio/rw.go +++ b/p2p/crypto/secio/rw.go @@ -9,7 +9,7 @@ import ( "crypto/hmac" - proto "github.com/gogo/protobuf/proto" + proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" msgio "github.com/jbenet/go-msgio" mpool "github.com/jbenet/go-msgio/mpool" context "golang.org/x/net/context" diff --git a/p2p/protocol/identify/id.go b/p2p/protocol/identify/id.go index c4a3ba4c4ae2b9dd06d6cae19b81e6338ac961cd..c0de4bb9951872396e6c3b940ac42c35343789ff 100644 --- a/p2p/protocol/identify/id.go +++ b/p2p/protocol/identify/id.go @@ -5,8 +5,8 @@ import ( "sync" ma "QmaA6aDzeHjZiuqBtgYRz8ZXb1qMCoyMHgyDjBEYQniUKF/go-multiaddr" + ggio "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/io" semver "github.com/coreos/go-semver/semver" - ggio "github.com/gogo/protobuf/io" msmux "github.com/whyrusleeping/go-multistream" context "golang.org/x/net/context" diff --git a/p2p/protocol/identify/pb/identify.pb.go b/p2p/protocol/identify/pb/identify.pb.go index cc4cba4975ec35d0c19cf50c6c2027f73bf489a9..dc895b72aff3262d942bd8563e1d57adddd6cfa7 100644 --- a/p2p/protocol/identify/pb/identify.pb.go +++ b/p2p/protocol/identify/pb/identify.pb.go @@ -13,7 +13,7 @@ It has these top-level messages: */ package identify_pb -import proto "github.com/gogo/protobuf/proto" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" import math "math" // Reference imports to suppress errors if they are not otherwise used. diff --git a/package.json b/package.json index 7b61e8e9b20c43d140748886239c32d19aa39f62..900990548bb9bcc666069e28dd5ed32f3100e59f 100644 --- a/package.json +++ b/package.json @@ -22,6 +22,11 @@ "name": "multiaddr-filter", "hash": "QmVdADza4QFVAR9xqAxRQjt9vTZJ6UrVLgBstKua1Xg7he", "version": "1.0.0" + }, + { + "name": "gogo-protobuf", + "hash": "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R", + "version": "1.0.0" } ], "language": "go" diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/.travis.yml b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/.travis.yml new file mode 100644 index 0000000000000000000000000000000000000000..0e8f3f6c1917971bf32d573d83037468f74d10e6 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/.travis.yml @@ -0,0 +1,19 @@ +env: + - PROTOBUF_VERSION=2.5.0 + - PROTOBUF_VERSION=2.6.1 + - PROTOBUF_VERSION=3.0.0-alpha-3 + +before_install: + - ./install-protobuf.sh + - PATH=/home/travis/bin:$PATH protoc --version + +script: + - PATH=/home/travis/bin:$PATH make all + +language: go + +go: + - 1.2.2 + - 1.3.3 + - 1.4.2 + - 1.5 diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/CONTRIBUTORS b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/CONTRIBUTORS new file mode 100644 index 0000000000000000000000000000000000000000..32c30b8a58d1c8b5ea0aaca8534e438c3b43dc2c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/CONTRIBUTORS @@ -0,0 +1,14 @@ +This is a list of contributors to the GoGo protobuf repository. + +# Names should be added to this file like so: +# Name + +# Please keep the list sorted. + +Walter Schulze + +The contributors to the Go protobuf repository: + +# This source code was written by the Go contributors. +# The master list of contributors is in the main Go distribution, +# visible at http://tip.golang.org/CONTRIBUTORS. diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/LICENSE b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..335e38e19b97f36c4c8f94b557054e8d1c5bae39 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/LICENSE @@ -0,0 +1,36 @@ +Extensions for Protocol Buffers to create more go like structures. + +Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +http://github.com/gogo/protobuf/gogoproto + +Go support for Protocol Buffers - Google's data interchange format + +Copyright 2010 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. + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..b2562727c1b71f37578ef8a3d1f8c78a60fa508c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/Makefile @@ -0,0 +1,115 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/protobuf/gogoproto +# +# 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. +# +# 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. + +.PHONY: nuke regenerate tests clean install gofmt vet + +all: clean install regenerate install tests errcheck vet + +install: + go install ./proto + go install ./gogoproto + go install ./jsonpb + go install ./protoc-gen-gogo + go install ./protoc-gen-gofast + go install ./protoc-gen-gogofast + go install ./protoc-gen-gogofaster + go install ./protoc-gen-gogoslick + go install ./protoc-min-version + go install ./protoc-gen-combo + +clean: + go clean ./... + +nuke: + go clean -i ./... + +gofmt: + gofmt -l -s -w . + +regenerate: + make -C protoc-gen-gogo/descriptor regenerate + make -C protoc-gen-gogo/plugin regenerate + make -C gogoproto regenerate + make -C proto/testdata regenerate + make -C jsonpb/jsonpb_test_proto regenerate + make -C test regenerate + make -C test/example regenerate + make -C test/unrecognized regenerate + make -C test/group regenerate + make -C test/unrecognizedgroup regenerate + make -C test/enumstringer regenerate + make -C test/unmarshalmerge regenerate + make -C test/moredefaults regenerate + make -C test/issue8 regenerate + make -C test/enumprefix regenerate + make -C test/packed regenerate + make -C test/tags regenerate + make -C test/oneof regenerate + make -C test/oneof3 regenerate + make -C test/theproto3 regenerate + make -C test/mapsproto2 regenerate + make -C test/issue42order regenerate + make -C proto generate-test-pbs + make -C test/importdedup regenerate + make -C test/custombytesnonstruct regenerate + make -C test/required regenerate + make -C test/casttype regenerate + make -C vanity/test regenerate + make -C test/sizeunderscore regenerate + make -C test/issue34 regenerate + make -C test/empty-issue70 regenerate + make -C test/indeximport-issue72 regenerate + make -C test/fuzztests regenerate + make -C test/oneofembed regenerate + make gofmt + +tests: + go build ./test/enumprefix + go test ./... + +vet: + go vet ./... + go tool vet --shadow . + +errcheck: + go get -u github.com/kisielk/errcheck + errcheck ./test/... + +drone: + sudo apt-get install protobuf-compiler + (cd $(GOPATH)/src/github.com/gogo/protobuf && make all) + +testall: + make -C protoc-gen-gogo/testdata test + make -C vanity/test test + make tests + +bench: + (cd test/mixbench && go build .) + (cd test/mixbench && ./mixbench) + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/README b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/README new file mode 100644 index 0000000000000000000000000000000000000000..eb87463cb0690fdfb3d9a80acc50cba91438292f --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/README @@ -0,0 +1,177 @@ +GoGoProtobuf http://github.com/gogo/protobuf extends +GoProtobuf http://github.com/golang/protobuf + +Go support for Protocol Buffers - Google's data interchange format +Copyright 2010 The Go Authors. +https://github.com/golang/protobuf + +This package and the code it generates requires at least Go 1.4. + +This software implements Go bindings for protocol buffers. For +information about protocol buffers themselves, see + https://developers.google.com/protocol-buffers/ +To use this software, you must first install the standard C++ +implementation of protocol buffers from + https://developers.google.com/protocol-buffers/ +And of course you must also install the Go compiler and tools from + https://golang.org/ +See + https://golang.org/doc/install +for details or, if you are using gccgo, follow the instructions at + https://golang.org/doc/install/gccgo + +This software has two parts: a 'protocol compiler plugin' that +generates Go source files that, once compiled, can access and manage +protocol buffers; and a library that implements run-time support for +encoding (marshaling), decoding (unmarshaling), and accessing protocol +buffers. + +There is support for gRPC in Go using protocol buffers. +See the note at the bottom of this file for details. + +There are no insertion points in the plugin. + +GoGoProtobuf provides extensions for protocol buffers and GoProtobuf +see http://github.com/gogo/protobuf/gogoproto/doc.go + +To install this code: + +The simplest way is to run go get. + + # Grab the code from the repository and install the proto package. + go get -u github.com/gogo/protobuf/proto + go get -u github.com/gogo/protobuf/protoc-gen-gogo + go get -u github.com/gogo/protobuf/gogoproto + +The compiler plugin, protoc-gen-gogo, will be installed in $GOBIN, +defaulting to $GOPATH/bin. It must be in your $PATH for the protocol +compiler, protoc, to find it. + +Once the software is installed, there are two steps to using it. +First you must compile the protocol buffer definitions and then import +them, with the support library, into your program. + +To compile the protocol buffer definition, run protoc with the --gogo_out +parameter set to the directory you want to output the Go code to. + + protoc --gogo_out=. *.proto + +The generated files will be suffixed .pb.go. See the Test code below +for an example using such a file. + +The package comment for the proto library contains text describing +the interface provided in Go for protocol buffers. Here is an edited +version. + +If you are using any gogo.proto extensions you will need to specify the +proto_path to include the descriptor.proto and gogo.proto. +gogo.proto is located in github.com/gogo/protobuf/gogoproto +This should be fine, since your import is the same. +descriptor.proto is located in either github.com/gogo/protobuf/protobuf +or code.google.com/p/protobuf/trunk/src/ +Its import is google/protobuf/descriptor.proto so it might need some help. + + protoc --gogo_out=. -I=.:github.com/gogo/protobuf/protobuf *.proto + +========== + +The proto package converts data structures to and from the +wire format of protocol buffers. It works in concert with the +Go source code generated for .proto files by the protocol compiler. + +A summary of the properties of the protocol buffer interface +for a protocol buffer variable v: + + - Names are turned from camel_case to CamelCase for export. + - There are no methods on v to set fields; just treat + them as structure fields. + - There are getters that return a field's value if set, + and return the field's default value if unset. + The getters work even if the receiver is a nil message. + - The zero value for a struct is its correct initialization state. + All desired fields must be set before marshaling. + - A Reset() method will restore a protobuf struct to its zero state. + - Non-repeated fields are pointers to the values; nil means unset. + That is, optional or required field int32 f becomes F *int32. + - Repeated fields are slices. + - Helper functions are available to aid the setting of fields. + Helpers for getting values are superseded by the + GetFoo methods and their use is deprecated. + msg.Foo = proto.String("hello") // set field + - Constants are defined to hold the default values of all fields that + have them. They have the form Default_StructName_FieldName. + Because the getter methods handle defaulted values, + direct use of these constants should be rare. + - Enums are given type names and maps from names to values. + Enum values are prefixed with the enum's type name. Enum types have + a String method, and a Enum method to assist in message construction. + - Nested groups and enums have type names prefixed with the name of + the surrounding message type. + - Extensions are given descriptor names that start with E_, + followed by an underscore-delimited list of the nested messages + that contain it (if any) followed by the CamelCased name of the + extension field itself. HasExtension, ClearExtension, GetExtension + and SetExtension are functions for manipulating extensions. + - Oneof field sets are given a single field in their message, + with distinguished wrapper types for each possible field value. + - Marshal and Unmarshal are functions to encode and decode the wire format. + +Consider file test.proto, containing + + package example; + + enum FOO { X = 17; }; + + message Test { + required string label = 1; + optional int32 type = 2 [default=77]; + repeated int64 reps = 3; + optional group OptionalGroup = 4 { + required string RequiredField = 5; + } + } + +To create and play with a Test object from the example package, + + package main + + import ( + "log" + + "github.com/gogo/protobuf/proto" + "path/to/example" + ) + + func main() { + test := &example.Test { + Label: proto.String("hello"), + Type: proto.Int32(17), + Optionalgroup: &example.Test_OptionalGroup { + RequiredField: proto.String("good bye"), + }, + } + data, err := proto.Marshal(test) + if err != nil { + log.Fatal("marshaling error: ", err) + } + newTest := &example.Test{} + err = proto.Unmarshal(data, newTest) + if err != nil { + log.Fatal("unmarshaling error: ", err) + } + // Now test and newTest contain the same data. + if test.GetLabel() != newTest.GetLabel() { + log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel()) + } + // etc. + } + + +gRPC Support +============ +If a proto file specifies RPC services, protoc-gen-go can be instructed to +generate code compatible with gRPC (http://www.grpc.io/). To do this, pass +the `plugins` parameter to protoc-gen-go; the usual way is to insert it into +the --go_out argument to protoc: + + protoc --gogo_out=plugins=grpc:. *.proto diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/Readme.md b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/Readme.md new file mode 100644 index 0000000000000000000000000000000000000000..094e74395be03fef0eedf1f75dbdf814ce880300 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/Readme.md @@ -0,0 +1,52 @@ +# Protocol Buffers for Go with Gadgets + +Drone.io Basic Tests: [![Build Status](https://drone.io/github.com/gogo/protobuf/status.png)](https://drone.io/github.com/gogo/protobuf/latest) + +Travis CI Matrix Builds: [![Build Status](https://travis-ci.org/gogo/protobuf.svg?branch=master)](https://travis-ci.org/gogo/protobuf) + +### Getting Started (Give me the speed I don't care about the rest) + +Install the protoc-gen-gofast binary + + go get github.com/gogo/protobuf/protoc-gen-gofast + +Use it to generate faster marshaling and unmarshaling go code for you protocol buffers. + + protoc --gofast_out=. myproto.proto + +### Getting started (I have heard about fields without pointers and more code generation) + +Other binaries are also included: + + protoc-gen-gogofast (same as gofast, but imports gogoprotobuf) + protoc-gen-gogofaster (same as gogofast, without XXX_unrecognized, less pointer fields) + protoc-gen-gogoslick (same as gogofaster, but with generated string, gostring and equal methods) + +### Getting started (I want more customization power over fields, speed, other serialization formats and tests, etc.) + +Please visit the [homepage](http://gogo.github.io) for more documentation. + +### Installation + +To install it, you must first have Go (at least version 1.2.2) installed (see [http://golang.org/doc/install](http://golang.org/doc/install)). Go 1.2.2, 1.3.3, 1.4.2 and 1.5 are continiuosly tested. + +Next, install the standard protocol buffer implementation from [https://github.com/google/protobuf](https://github.com/google/protobuf). +Most versions from 2.3.1 should not give any problems, but 2.5.0, 2.6.1 and 3 alpha are continiously tested. + +Finally run: + + go get github.com/gogo/protobuf/proto + go get github.com/gogo/protobuf/protoc-gen-gogo + go get github.com/gogo/protobuf/gogoproto + +### Proto3 + +Proto3 is supported, but most of the new native types are not supported yet. +[See Proto3 Issue](https://github.com/gogo/protobuf/issues/57) for more details. + +### GRPC + +It works the same as golang/protobuf, simply specify the plugin. +Here is an example using gofast: + + protoc --gofast_out=plugins=grpc:. my.proto diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/codec/codec.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/codec/codec.go new file mode 100644 index 0000000000000000000000000000000000000000..2fc2fdbfb3400a262f5104fa920e08d9eb90ba2c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/codec/codec.go @@ -0,0 +1,73 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 codec + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +) + +type Codec interface { + Marshal(v interface{}) ([]byte, error) + Unmarshal(data []byte, v interface{}) error + String() string +} + +type marshaler interface { + MarshalTo(data []byte) (n int, err error) + Size() (n int) +} + +type codec struct { + buf []byte +} + +func (this *codec) String() string { + return "proto" +} + +func New(size int) Codec { + return &codec{make([]byte, size)} +} + +func (this *codec) Marshal(v interface{}) ([]byte, error) { + if m, ok := v.(marshaler); ok { + n := m.Size() + if n > len(this.buf) { + this.buf = make([]byte, n) + } + _, err := m.MarshalTo(this.buf) + if err != nil { + return nil, err + } + return this.buf[:n], nil + } + return proto.Marshal(v.(proto.Message)) +} + +func (this *codec) Unmarshal(data []byte, v interface{}) error { + return proto.Unmarshal(data, v.(proto.Message)) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/codec/codec_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/codec/codec_test.go new file mode 100644 index 0000000000000000000000000000000000000000..f867380440953cba9481e3ba5b690b35314bff54 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/codec/codec_test.go @@ -0,0 +1,52 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 codec + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test" + "math/rand" + "testing" + "time" +) + +func TestCodec(t *testing.T) { + r := rand.New(rand.NewSource(time.Now().UnixNano())) + in := test.NewPopulatedNinOptStruct(r, true) + c := New(r.Intn(1024)) + data, err := c.Marshal(in) + if err != nil { + t.Fatal(err) + } + out := &test.NinOptStruct{} + err = c.Unmarshal(data, out) + if err != nil { + t.Fatal(err) + } + if err := in.VerboseEqual(out); err != nil { + t.Fatal(err) + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..557f294933088c030618042a9612fd7b2844540d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/Makefile @@ -0,0 +1,36 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/protobuf/gogoproto +# +# 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. +# +# 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 --gogo_out=Mgoogle/protobuf/descriptor.proto=github.com/gogo/protobuf/protoc-gen-gogo/descriptor:. --proto_path=../../../../:../protobuf/:. *.proto + +restore: + cp gogo.pb.golden gogo.pb.go + +preserve: + cp gogo.pb.go gogo.pb.golden diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/doc.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/doc.go new file mode 100644 index 0000000000000000000000000000000000000000..fe33f4ba6102f774f501510066ac81edd7519eb5 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/doc.go @@ -0,0 +1,166 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 gogoproto provides extensions for protocol buffers to achieve: + + - fast marshalling and unmarshalling. + - peace of mind by optionally generating test and benchmark code. + - more canonical Go structures. + - less typing by optionally generating extra helper code. + - goprotobuf compatibility + +More Canonical Go Structures + +A lot of time working with a goprotobuf struct will lead you to a place where you create another struct that is easier to work with and then have a function to copy the values between the two structs. +You might also find that basic structs that started their life as part of an API need to be sent over the wire. With gob, you could just send it. With goprotobuf, you need to make a parallel struct. +Gogoprotobuf tries to fix these problems with the nullable, embed, customtype and customname field extensions. + + - nullable, if false, a field is generated without a pointer (see warning below). + - embed, if true, the field is generated as an embedded field. + - customtype, It works with the Marshal and Unmarshal methods, to allow you to have your own types in your struct, but marshal to bytes. For example, custom.Uuid or custom.Fixed128 + - customname (beta), Changes the generated fieldname. This is especially useful when generated methods conflict with fieldnames. + - casttype (beta), Changes the generated fieldtype. All generated code assumes that this type is castable to the protocol buffer field type. It does not work for maps, structs or enums. + +Warning about nullable: According to the Protocol Buffer specification, you should be able to tell whether a field is set or unset. With the option nullable=false this feature is lost, since your non-nullable fields will always be set. It can be seen as a layer on top of Protocol Buffers, where before and after marshalling all non-nullable fields are set and they cannot be unset. + +Let us look at: + + github.com/gogo/protobuf/test/example/example.proto + +for a quicker overview. + +The following message: + + package test; + + import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + + message A { + optional string Description = 1 [(gogoproto.nullable) = false]; + optional int64 Number = 2 [(gogoproto.nullable) = false]; + optional bytes Id = 3 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uuid", (gogoproto.nullable) = false]; + } + +Will generate a go struct which looks a lot like this: + + type A struct { + Description string + Number int64 + Id github_com_gogo_protobuf_test_custom.Uuid + } + +You will see there are no pointers, since all fields are non-nullable. +You will also see a custom type which marshals to a string. +Be warned it is your responsibility to test your custom types thoroughly. +You should think of every possible empty and nil case for your marshaling, unmarshaling and size methods. + +Next we will embed the message A in message B. + + message B { + optional A A = 1 [(gogoproto.nullable) = false, (gogoproto.embed) = true]; + repeated bytes G = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; + } + +See below that A is embedded in B. + + type B struct { + A + G []github_com_gogo_protobuf_test_custom.Uint128 + } + +Also see the repeated custom type. + + type Uint128 [2]uint64 + +Next we will create a custom name for one of our fields. + + message C { + optional int64 size = 1 [(gogoproto.customname) = "MySize"]; + } + +See below that the field's name is MySize and not Size. + + type C struct { + MySize *int64 + } + +The is useful when having a protocol buffer message with a field name which conflicts with a generated method. +As an example, having a field name size and using the sizer plugin to generate a Size method will cause a go compiler error. +Using customname you can fix this error without changing the field name. +This is typically useful when working with a protocol buffer that was designed before these methods and/or the go language were avialable. + +Gogoprotobuf also has some more subtle changes, these could be changed back: + + - the generated package name for imports do not have the extra /filename.pb, + but are actually the imports specified in the .proto file. + +Gogoprotobuf also has lost some features which should be brought back with time: + + - Marshalling and unmarshalling with reflect and without the unsafe package, + this requires work in pointer_reflect.go + +Why does nullable break protocol buffer specifications: + +The protocol buffer specification states, somewhere, that you should be able to tell whether a +field is set or unset. With the option nullable=false this feature is lost, +since your non-nullable fields will always be set. It can be seen as a layer on top of +protocol buffers, where before and after marshalling all non-nullable fields are set +and they cannot be unset. + +Goprotobuf Compatibility: + +Gogoprotobuf is compatible with Goprotobuf, because it is compatible with protocol buffers. +Gogoprotobuf generates the same code as goprotobuf if no extensions are used. +The enumprefix, getters and stringer extensions can be used to remove some of the unnecessary code generated by goprotobuf: + + - gogoproto_import, if false, the generated code imports github.com/golang/protobuf/proto instead of github.com/gogo/protobuf/proto. + - goproto_enum_prefix, if false, generates the enum constant names without the messagetype prefix + - goproto_enum_stringer (experimental), if false, the enum is generated without the default string method, this is useful for rather using enum_stringer, or allowing you to write your own string method. + - goproto_getters, if false, the message is generated without get methods, this is useful when you would rather want to use face + - goproto_stringer, if false, the message is generated without the default string method, this is useful for rather using stringer, or allowing you to write your own string method. + - goproto_extensions_map (beta), if false, the extensions field is generated as type []byte instead of type map[int32]proto.Extension + - goproto_unrecognized (beta), if false, XXX_unrecognized field is not generated. This is useful in conjunction with gogoproto.nullable=false, to generate structures completely devoid of pointers and reduce GC pressure at the cost of losing information about unrecognized fields. + +Less Typing and Peace of Mind is explained in their specific plugin folders godoc: + + - github.com/gogo/protobuf/plugin/ + +If you do not use any of these extension the code that is generated +will be the same as if goprotobuf has generated it. + +The most complete way to see examples is to look at + + github.com/gogo/protobuf/test/thetest.proto + +Gogoprototest is a seperate project, +because we want to keep gogoprotobuf independant of goprotobuf, +but we still want to test it thoroughly. + +*/ +package gogoproto diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/gogo.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/gogo.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..ab6514c208dda6a1ea4cbba8595f376b9d180d23 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/gogo.pb.go @@ -0,0 +1,494 @@ +// Code generated by protoc-gen-gogo. +// source: gogo.proto +// DO NOT EDIT! + +/* +Package gogoproto is a generated protocol buffer package. + +It is generated from these files: + gogo.proto + +It has these top-level messages: +*/ +package gogoproto + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +var E_GoprotoEnumPrefix = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.EnumOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 62001, + Name: "gogoproto.goproto_enum_prefix", + Tag: "varint,62001,opt,name=goproto_enum_prefix", +} + +var E_GoprotoEnumStringer = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.EnumOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 62021, + Name: "gogoproto.goproto_enum_stringer", + Tag: "varint,62021,opt,name=goproto_enum_stringer", +} + +var E_EnumStringer = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.EnumOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 62022, + Name: "gogoproto.enum_stringer", + Tag: "varint,62022,opt,name=enum_stringer", +} + +var E_GoprotoGettersAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63001, + Name: "gogoproto.goproto_getters_all", + Tag: "varint,63001,opt,name=goproto_getters_all", +} + +var E_GoprotoEnumPrefixAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63002, + Name: "gogoproto.goproto_enum_prefix_all", + Tag: "varint,63002,opt,name=goproto_enum_prefix_all", +} + +var E_GoprotoStringerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63003, + Name: "gogoproto.goproto_stringer_all", + Tag: "varint,63003,opt,name=goproto_stringer_all", +} + +var E_VerboseEqualAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63004, + Name: "gogoproto.verbose_equal_all", + Tag: "varint,63004,opt,name=verbose_equal_all", +} + +var E_FaceAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63005, + Name: "gogoproto.face_all", + Tag: "varint,63005,opt,name=face_all", +} + +var E_GostringAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63006, + Name: "gogoproto.gostring_all", + Tag: "varint,63006,opt,name=gostring_all", +} + +var E_PopulateAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63007, + Name: "gogoproto.populate_all", + Tag: "varint,63007,opt,name=populate_all", +} + +var E_StringerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63008, + Name: "gogoproto.stringer_all", + Tag: "varint,63008,opt,name=stringer_all", +} + +var E_OnlyoneAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63009, + Name: "gogoproto.onlyone_all", + Tag: "varint,63009,opt,name=onlyone_all", +} + +var E_EqualAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63013, + Name: "gogoproto.equal_all", + Tag: "varint,63013,opt,name=equal_all", +} + +var E_DescriptionAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63014, + Name: "gogoproto.description_all", + Tag: "varint,63014,opt,name=description_all", +} + +var E_TestgenAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63015, + Name: "gogoproto.testgen_all", + Tag: "varint,63015,opt,name=testgen_all", +} + +var E_BenchgenAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63016, + Name: "gogoproto.benchgen_all", + Tag: "varint,63016,opt,name=benchgen_all", +} + +var E_MarshalerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63017, + Name: "gogoproto.marshaler_all", + Tag: "varint,63017,opt,name=marshaler_all", +} + +var E_UnmarshalerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63018, + Name: "gogoproto.unmarshaler_all", + Tag: "varint,63018,opt,name=unmarshaler_all", +} + +var E_SizerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63020, + Name: "gogoproto.sizer_all", + Tag: "varint,63020,opt,name=sizer_all", +} + +var E_GoprotoEnumStringerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63021, + Name: "gogoproto.goproto_enum_stringer_all", + Tag: "varint,63021,opt,name=goproto_enum_stringer_all", +} + +var E_EnumStringerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63022, + Name: "gogoproto.enum_stringer_all", + Tag: "varint,63022,opt,name=enum_stringer_all", +} + +var E_UnsafeMarshalerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63023, + Name: "gogoproto.unsafe_marshaler_all", + Tag: "varint,63023,opt,name=unsafe_marshaler_all", +} + +var E_UnsafeUnmarshalerAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63024, + Name: "gogoproto.unsafe_unmarshaler_all", + Tag: "varint,63024,opt,name=unsafe_unmarshaler_all", +} + +var E_GoprotoExtensionsMapAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63025, + Name: "gogoproto.goproto_extensions_map_all", + Tag: "varint,63025,opt,name=goproto_extensions_map_all", +} + +var E_GoprotoUnrecognizedAll = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63026, + Name: "gogoproto.goproto_unrecognized_all", + Tag: "varint,63026,opt,name=goproto_unrecognized_all", +} + +var E_GogoprotoImport = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FileOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 63027, + Name: "gogoproto.gogoproto_import", + Tag: "varint,63027,opt,name=gogoproto_import", +} + +var E_GoprotoGetters = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64001, + Name: "gogoproto.goproto_getters", + Tag: "varint,64001,opt,name=goproto_getters", +} + +var E_GoprotoStringer = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64003, + Name: "gogoproto.goproto_stringer", + Tag: "varint,64003,opt,name=goproto_stringer", +} + +var E_VerboseEqual = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64004, + Name: "gogoproto.verbose_equal", + Tag: "varint,64004,opt,name=verbose_equal", +} + +var E_Face = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64005, + Name: "gogoproto.face", + Tag: "varint,64005,opt,name=face", +} + +var E_Gostring = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64006, + Name: "gogoproto.gostring", + Tag: "varint,64006,opt,name=gostring", +} + +var E_Populate = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64007, + Name: "gogoproto.populate", + Tag: "varint,64007,opt,name=populate", +} + +var E_Stringer = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 67008, + Name: "gogoproto.stringer", + Tag: "varint,67008,opt,name=stringer", +} + +var E_Onlyone = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64009, + Name: "gogoproto.onlyone", + Tag: "varint,64009,opt,name=onlyone", +} + +var E_Equal = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64013, + Name: "gogoproto.equal", + Tag: "varint,64013,opt,name=equal", +} + +var E_Description = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64014, + Name: "gogoproto.description", + Tag: "varint,64014,opt,name=description", +} + +var E_Testgen = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64015, + Name: "gogoproto.testgen", + Tag: "varint,64015,opt,name=testgen", +} + +var E_Benchgen = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64016, + Name: "gogoproto.benchgen", + Tag: "varint,64016,opt,name=benchgen", +} + +var E_Marshaler = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64017, + Name: "gogoproto.marshaler", + Tag: "varint,64017,opt,name=marshaler", +} + +var E_Unmarshaler = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64018, + Name: "gogoproto.unmarshaler", + Tag: "varint,64018,opt,name=unmarshaler", +} + +var E_Sizer = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64020, + Name: "gogoproto.sizer", + Tag: "varint,64020,opt,name=sizer", +} + +var E_UnsafeMarshaler = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64023, + Name: "gogoproto.unsafe_marshaler", + Tag: "varint,64023,opt,name=unsafe_marshaler", +} + +var E_UnsafeUnmarshaler = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64024, + Name: "gogoproto.unsafe_unmarshaler", + Tag: "varint,64024,opt,name=unsafe_unmarshaler", +} + +var E_GoprotoExtensionsMap = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64025, + Name: "gogoproto.goproto_extensions_map", + Tag: "varint,64025,opt,name=goproto_extensions_map", +} + +var E_GoprotoUnrecognized = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 64026, + Name: "gogoproto.goproto_unrecognized", + Tag: "varint,64026,opt,name=goproto_unrecognized", +} + +var E_Nullable = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 65001, + Name: "gogoproto.nullable", + Tag: "varint,65001,opt,name=nullable", +} + +var E_Embed = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 65002, + Name: "gogoproto.embed", + Tag: "varint,65002,opt,name=embed", +} + +var E_Customtype = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65003, + Name: "gogoproto.customtype", + Tag: "bytes,65003,opt,name=customtype", +} + +var E_Customname = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65004, + Name: "gogoproto.customname", + Tag: "bytes,65004,opt,name=customname", +} + +var E_Jsontag = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65005, + Name: "gogoproto.jsontag", + Tag: "bytes,65005,opt,name=jsontag", +} + +var E_Moretags = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65006, + Name: "gogoproto.moretags", + Tag: "bytes,65006,opt,name=moretags", +} + +var E_Casttype = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 65007, + Name: "gogoproto.casttype", + Tag: "bytes,65007,opt,name=casttype", +} + +func init() { + proto.RegisterExtension(E_GoprotoEnumPrefix) + proto.RegisterExtension(E_GoprotoEnumStringer) + proto.RegisterExtension(E_EnumStringer) + proto.RegisterExtension(E_GoprotoGettersAll) + proto.RegisterExtension(E_GoprotoEnumPrefixAll) + proto.RegisterExtension(E_GoprotoStringerAll) + proto.RegisterExtension(E_VerboseEqualAll) + proto.RegisterExtension(E_FaceAll) + proto.RegisterExtension(E_GostringAll) + proto.RegisterExtension(E_PopulateAll) + proto.RegisterExtension(E_StringerAll) + proto.RegisterExtension(E_OnlyoneAll) + proto.RegisterExtension(E_EqualAll) + proto.RegisterExtension(E_DescriptionAll) + proto.RegisterExtension(E_TestgenAll) + proto.RegisterExtension(E_BenchgenAll) + proto.RegisterExtension(E_MarshalerAll) + proto.RegisterExtension(E_UnmarshalerAll) + proto.RegisterExtension(E_SizerAll) + proto.RegisterExtension(E_GoprotoEnumStringerAll) + proto.RegisterExtension(E_EnumStringerAll) + proto.RegisterExtension(E_UnsafeMarshalerAll) + proto.RegisterExtension(E_UnsafeUnmarshalerAll) + proto.RegisterExtension(E_GoprotoExtensionsMapAll) + proto.RegisterExtension(E_GoprotoUnrecognizedAll) + proto.RegisterExtension(E_GogoprotoImport) + proto.RegisterExtension(E_GoprotoGetters) + proto.RegisterExtension(E_GoprotoStringer) + proto.RegisterExtension(E_VerboseEqual) + proto.RegisterExtension(E_Face) + proto.RegisterExtension(E_Gostring) + proto.RegisterExtension(E_Populate) + proto.RegisterExtension(E_Stringer) + proto.RegisterExtension(E_Onlyone) + proto.RegisterExtension(E_Equal) + proto.RegisterExtension(E_Description) + proto.RegisterExtension(E_Testgen) + proto.RegisterExtension(E_Benchgen) + proto.RegisterExtension(E_Marshaler) + proto.RegisterExtension(E_Unmarshaler) + proto.RegisterExtension(E_Sizer) + proto.RegisterExtension(E_UnsafeMarshaler) + proto.RegisterExtension(E_UnsafeUnmarshaler) + proto.RegisterExtension(E_GoprotoExtensionsMap) + proto.RegisterExtension(E_GoprotoUnrecognized) + proto.RegisterExtension(E_Nullable) + proto.RegisterExtension(E_Embed) + proto.RegisterExtension(E_Customtype) + proto.RegisterExtension(E_Customname) + proto.RegisterExtension(E_Jsontag) + proto.RegisterExtension(E_Moretags) + proto.RegisterExtension(E_Casttype) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/gogo.pb.golden b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/gogo.pb.golden new file mode 100644 index 0000000000000000000000000000000000000000..f6502e4b90155eccf7ed08efe9dd947a14d915b3 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/gogo.pb.golden @@ -0,0 +1,45 @@ +// Code generated by protoc-gen-go. +// source: gogo.proto +// DO NOT EDIT! + +package gogoproto + +import proto "github.com/gogo/protobuf/proto" +import json "encoding/json" +import math "math" +import google_protobuf "github.com/gogo/protobuf/protoc-gen-gogo/descriptor" + +// Reference proto, json, and math imports to suppress error if they are not otherwise used. +var _ = proto.Marshal +var _ = &json.SyntaxError{} +var _ = math.Inf + +var E_Nullable = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 51235, + Name: "gogoproto.nullable", + Tag: "varint,51235,opt,name=nullable", +} + +var E_Embed = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*bool)(nil), + Field: 51236, + Name: "gogoproto.embed", + Tag: "varint,51236,opt,name=embed", +} + +var E_Customtype = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 51237, + Name: "gogoproto.customtype", + Tag: "bytes,51237,opt,name=customtype", +} + +func init() { + proto.RegisterExtension(E_Nullable) + proto.RegisterExtension(E_Embed) + proto.RegisterExtension(E_Customtype) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/gogo.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/gogo.proto new file mode 100644 index 0000000000000000000000000000000000000000..54b7d18a9111674d17c25fa3af37d0cc477261bd --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/gogo.proto @@ -0,0 +1,107 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package gogoproto; + +import "google/protobuf/descriptor.proto"; + +option java_package = "com.google.protobuf"; +option java_outer_classname = "GoGoProtos"; + +extend google.protobuf.EnumOptions { + optional bool goproto_enum_prefix = 62001; + optional bool goproto_enum_stringer = 62021; + optional bool enum_stringer = 62022; +} + +extend google.protobuf.FileOptions { + optional bool goproto_getters_all = 63001; + optional bool goproto_enum_prefix_all = 63002; + optional bool goproto_stringer_all = 63003; + optional bool verbose_equal_all = 63004; + optional bool face_all = 63005; + optional bool gostring_all = 63006; + optional bool populate_all = 63007; + optional bool stringer_all = 63008; + optional bool onlyone_all = 63009; + + optional bool equal_all = 63013; + optional bool description_all = 63014; + optional bool testgen_all = 63015; + optional bool benchgen_all = 63016; + optional bool marshaler_all = 63017; + optional bool unmarshaler_all = 63018; + + optional bool sizer_all = 63020; + + optional bool goproto_enum_stringer_all = 63021; + optional bool enum_stringer_all = 63022; + + optional bool unsafe_marshaler_all = 63023; + optional bool unsafe_unmarshaler_all = 63024; + + optional bool goproto_extensions_map_all = 63025; + optional bool goproto_unrecognized_all = 63026; + optional bool gogoproto_import = 63027; +} + +extend google.protobuf.MessageOptions { + optional bool goproto_getters = 64001; + optional bool goproto_stringer = 64003; + optional bool verbose_equal = 64004; + optional bool face = 64005; + optional bool gostring = 64006; + optional bool populate = 64007; + optional bool stringer = 67008; + optional bool onlyone = 64009; + + optional bool equal = 64013; + optional bool description = 64014; + optional bool testgen = 64015; + optional bool benchgen = 64016; + optional bool marshaler = 64017; + optional bool unmarshaler = 64018; + + optional bool sizer = 64020; + + optional bool unsafe_marshaler = 64023; + optional bool unsafe_unmarshaler = 64024; + + optional bool goproto_extensions_map = 64025; + optional bool goproto_unrecognized = 64026; +} + +extend google.protobuf.FieldOptions { + optional bool nullable = 65001; + optional bool embed = 65002; + optional string customtype = 65003; + optional string customname = 65004; + optional string jsontag = 65005; + optional string moretags = 65006; + optional string casttype = 65007; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/helper.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/helper.go new file mode 100644 index 0000000000000000000000000000000000000000..1f634dc2868685b03fd2b0538b505f726737f102 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto/helper.go @@ -0,0 +1,213 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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 gogoproto + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +func IsEmbed(field *google_protobuf.FieldDescriptorProto) bool { + return proto.GetBoolExtension(field.Options, E_Embed, false) +} + +func IsNullable(field *google_protobuf.FieldDescriptorProto) bool { + return proto.GetBoolExtension(field.Options, E_Nullable, true) +} + +func IsCustomType(field *google_protobuf.FieldDescriptorProto) bool { + typ := GetCustomType(field) + if len(typ) > 0 { + return true + } + return false +} + +func IsCastType(field *google_protobuf.FieldDescriptorProto) bool { + typ := GetCastType(field) + if len(typ) > 0 { + return true + } + return false +} + +func GetCustomType(field *google_protobuf.FieldDescriptorProto) string { + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Customtype) + if err == nil && v.(*string) != nil { + return *(v.(*string)) + } + } + return "" +} + +func GetCastType(field *google_protobuf.FieldDescriptorProto) string { + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Casttype) + if err == nil && v.(*string) != nil { + return *(v.(*string)) + } + } + return "" +} + +func IsCustomName(field *google_protobuf.FieldDescriptorProto) bool { + name := GetCustomName(field) + if len(name) > 0 { + return true + } + return false +} + +func GetCustomName(field *google_protobuf.FieldDescriptorProto) string { + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Customname) + if err == nil && v.(*string) != nil { + return *(v.(*string)) + } + } + return "" +} + +func GetJsonTag(field *google_protobuf.FieldDescriptorProto) *string { + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Jsontag) + if err == nil && v.(*string) != nil { + return (v.(*string)) + } + } + return nil +} + +func GetMoreTags(field *google_protobuf.FieldDescriptorProto) *string { + if field.Options != nil { + v, err := proto.GetExtension(field.Options, E_Moretags) + if err == nil && v.(*string) != nil { + return (v.(*string)) + } + } + return nil +} + +type EnableFunc func(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool + +func EnabledGoEnumPrefix(file *google_protobuf.FileDescriptorProto, enum *google_protobuf.EnumDescriptorProto) bool { + return proto.GetBoolExtension(enum.Options, E_GoprotoEnumPrefix, proto.GetBoolExtension(file.Options, E_GoprotoEnumPrefixAll, true)) +} + +func EnabledGoStringer(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_GoprotoStringer, proto.GetBoolExtension(file.Options, E_GoprotoStringerAll, true)) +} + +func HasGoGetters(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_GoprotoGetters, proto.GetBoolExtension(file.Options, E_GoprotoGettersAll, true)) +} + +func IsUnion(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Onlyone, proto.GetBoolExtension(file.Options, E_OnlyoneAll, false)) +} + +func HasGoString(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Gostring, proto.GetBoolExtension(file.Options, E_GostringAll, false)) +} + +func HasEqual(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Equal, proto.GetBoolExtension(file.Options, E_EqualAll, false)) +} + +func HasVerboseEqual(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_VerboseEqual, proto.GetBoolExtension(file.Options, E_VerboseEqualAll, false)) +} + +func IsStringer(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Stringer, proto.GetBoolExtension(file.Options, E_StringerAll, false)) +} + +func IsFace(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Face, proto.GetBoolExtension(file.Options, E_FaceAll, false)) +} + +func HasDescription(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Description, proto.GetBoolExtension(file.Options, E_DescriptionAll, false)) +} + +func HasPopulate(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Populate, proto.GetBoolExtension(file.Options, E_PopulateAll, false)) +} + +func HasTestGen(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Testgen, proto.GetBoolExtension(file.Options, E_TestgenAll, false)) +} + +func HasBenchGen(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Benchgen, proto.GetBoolExtension(file.Options, E_BenchgenAll, false)) +} + +func IsMarshaler(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Marshaler, proto.GetBoolExtension(file.Options, E_MarshalerAll, false)) +} + +func IsUnmarshaler(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Unmarshaler, proto.GetBoolExtension(file.Options, E_UnmarshalerAll, false)) +} + +func IsSizer(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_Sizer, proto.GetBoolExtension(file.Options, E_SizerAll, false)) +} + +func IsGoEnumStringer(file *google_protobuf.FileDescriptorProto, enum *google_protobuf.EnumDescriptorProto) bool { + return proto.GetBoolExtension(enum.Options, E_GoprotoEnumStringer, proto.GetBoolExtension(file.Options, E_GoprotoEnumStringerAll, true)) +} + +func IsEnumStringer(file *google_protobuf.FileDescriptorProto, enum *google_protobuf.EnumDescriptorProto) bool { + return proto.GetBoolExtension(enum.Options, E_EnumStringer, proto.GetBoolExtension(file.Options, E_EnumStringerAll, false)) +} + +func IsUnsafeMarshaler(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_UnsafeMarshaler, proto.GetBoolExtension(file.Options, E_UnsafeMarshalerAll, false)) +} + +func IsUnsafeUnmarshaler(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_UnsafeUnmarshaler, proto.GetBoolExtension(file.Options, E_UnsafeUnmarshalerAll, false)) +} + +func HasExtensionsMap(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + return proto.GetBoolExtension(message.Options, E_GoprotoExtensionsMap, proto.GetBoolExtension(file.Options, E_GoprotoExtensionsMapAll, true)) +} + +func HasUnrecognized(file *google_protobuf.FileDescriptorProto, message *google_protobuf.DescriptorProto) bool { + if IsProto3(file) { + return false + } + return proto.GetBoolExtension(message.Options, E_GoprotoUnrecognized, proto.GetBoolExtension(file.Options, E_GoprotoUnrecognizedAll, true)) +} + +func IsProto3(file *google_protobuf.FileDescriptorProto) bool { + return file.GetSyntax() == "proto3" +} + +func ImportsGoGoProto(file *google_protobuf.FileDescriptorProto) bool { + return proto.GetBoolExtension(file.Options, E_GogoprotoImport, true) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/install-protobuf.sh b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/install-protobuf.sh new file mode 100644 index 0000000000000000000000000000000000000000..be08aa2acd79c9a250281da8c872e7a7c6de25f3 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/install-protobuf.sh @@ -0,0 +1,27 @@ +#!/usr/bin/env bash + +set -ex + +die() { + echo "$@" >&2 + exit 1 +} + +case "$PROTOBUF_VERSION" in +2*) + basename=protobuf-$PROTOBUF_VERSION + ;; +3*) + basename=protobuf-cpp-$PROTOBUF_VERSION + ;; +*) + die "unknown protobuf version: $PROTOBUF_VERSION" + ;; +esac + +wget https://github.com/google/protobuf/releases/download/v$PROTOBUF_VERSION/$basename.tar.gz +tar xzf $basename.tar.gz + +cd protobuf-$PROTOBUF_VERSION + +./configure --prefix=/home/travis && make -j2 && make install diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/io/full.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/io/full.go new file mode 100644 index 0000000000000000000000000000000000000000..cc047eed936c0ab1b29e7d95002ef740c85ff5c4 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/io/full.go @@ -0,0 +1,96 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 io + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "io" +) + +func NewFullWriter(w io.Writer) WriteCloser { + return &fullWriter{w, nil} +} + +type fullWriter struct { + w io.Writer + buffer []byte +} + +func (this *fullWriter) WriteMsg(msg proto.Message) (err error) { + var data []byte + if m, ok := msg.(marshaler); ok { + n := m.Size() + if n >= len(this.buffer) { + this.buffer = make([]byte, n) + } + _, err = m.MarshalTo(this.buffer) + if err != nil { + return err + } + data = this.buffer[:n] + } else { + data, err = proto.Marshal(msg) + if err != nil { + return err + } + } + _, err = this.w.Write(data) + return err +} + +func (this *fullWriter) Close() error { + if closer, ok := this.w.(io.Closer); ok { + return closer.Close() + } + return nil +} + +type fullReader struct { + r io.Reader + buf []byte +} + +func NewFullReader(r io.Reader, maxSize int) ReadCloser { + return &fullReader{r, make([]byte, maxSize)} +} + +func (this *fullReader) ReadMsg(msg proto.Message) error { + length, err := this.r.Read(this.buf) + if err != nil { + return err + } + return proto.Unmarshal(this.buf[:length], msg) +} + +func (this *fullReader) Close() error { + if closer, ok := this.r.(io.Closer); ok { + return closer.Close() + } + return nil +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/io/io.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/io/io.go new file mode 100644 index 0000000000000000000000000000000000000000..44f834ddd37420efccce2998520a68afcaa415cb --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/io/io.go @@ -0,0 +1,57 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 io + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "io" +) + +type Writer interface { + WriteMsg(proto.Message) error +} + +type WriteCloser interface { + Writer + io.Closer +} + +type Reader interface { + ReadMsg(msg proto.Message) error +} + +type ReadCloser interface { + Reader + io.Closer +} + +type marshaler interface { + MarshalTo(data []byte) (n int, err error) + Size() (n int) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/io/io_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/io/io_test.go new file mode 100644 index 0000000000000000000000000000000000000000..70170db5b8126d38fe1dcca6c3a7670f7144de17 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/io/io_test.go @@ -0,0 +1,221 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 io_test + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/io" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test" + "bytes" + "encoding/binary" + goio "io" + "math/rand" + "testing" + "time" +) + +func iotest(writer io.WriteCloser, reader io.ReadCloser) error { + size := 1000 + msgs := make([]*test.NinOptNative, size) + r := rand.New(rand.NewSource(time.Now().UnixNano())) + for i := range msgs { + msgs[i] = test.NewPopulatedNinOptNative(r, true) + //issue 31 + if i == 5 { + msgs[i] = &test.NinOptNative{} + } + //issue 31 + if i == 999 { + msgs[i] = &test.NinOptNative{} + } + err := writer.WriteMsg(msgs[i]) + if err != nil { + return err + } + } + if err := writer.Close(); err != nil { + return err + } + i := 0 + for { + msg := &test.NinOptNative{} + if err := reader.ReadMsg(msg); err != nil { + if err == goio.EOF { + break + } + return err + } + if err := msg.VerboseEqual(msgs[i]); err != nil { + return err + } + i++ + } + if i != size { + panic("not enough messages read") + } + if err := reader.Close(); err != nil { + return err + } + return nil +} + +type buffer struct { + *bytes.Buffer + closed bool +} + +func (this *buffer) Close() error { + this.closed = true + return nil +} + +func newBuffer() *buffer { + return &buffer{bytes.NewBuffer(nil), false} +} + +func TestBigUint32Normal(t *testing.T) { + buf := newBuffer() + writer := io.NewUint32DelimitedWriter(buf, binary.BigEndian) + reader := io.NewUint32DelimitedReader(buf, binary.BigEndian, 1024*1024) + if err := iotest(writer, reader); err != nil { + t.Error(err) + } + if !buf.closed { + t.Fatalf("did not close buffer") + } +} + +func TestBigUint32MaxSize(t *testing.T) { + buf := newBuffer() + writer := io.NewUint32DelimitedWriter(buf, binary.BigEndian) + reader := io.NewUint32DelimitedReader(buf, binary.BigEndian, 20) + if err := iotest(writer, reader); err != goio.ErrShortBuffer { + t.Error(err) + } else { + t.Logf("%s", err) + } +} + +func TestLittleUint32Normal(t *testing.T) { + buf := newBuffer() + writer := io.NewUint32DelimitedWriter(buf, binary.LittleEndian) + reader := io.NewUint32DelimitedReader(buf, binary.LittleEndian, 1024*1024) + if err := iotest(writer, reader); err != nil { + t.Error(err) + } + if !buf.closed { + t.Fatalf("did not close buffer") + } +} + +func TestLittleUint32MaxSize(t *testing.T) { + buf := newBuffer() + writer := io.NewUint32DelimitedWriter(buf, binary.LittleEndian) + reader := io.NewUint32DelimitedReader(buf, binary.LittleEndian, 20) + if err := iotest(writer, reader); err != goio.ErrShortBuffer { + t.Error(err) + } else { + t.Logf("%s", err) + } +} + +func TestVarintNormal(t *testing.T) { + buf := newBuffer() + writer := io.NewDelimitedWriter(buf) + reader := io.NewDelimitedReader(buf, 1024*1024) + if err := iotest(writer, reader); err != nil { + t.Error(err) + } + if !buf.closed { + t.Fatalf("did not close buffer") + } +} + +func TestVarintNoClose(t *testing.T) { + buf := bytes.NewBuffer(nil) + writer := io.NewDelimitedWriter(buf) + reader := io.NewDelimitedReader(buf, 1024*1024) + if err := iotest(writer, reader); err != nil { + t.Error(err) + } +} + +//issue 32 +func TestVarintMaxSize(t *testing.T) { + buf := newBuffer() + writer := io.NewDelimitedWriter(buf) + reader := io.NewDelimitedReader(buf, 20) + if err := iotest(writer, reader); err != goio.ErrShortBuffer { + t.Error(err) + } else { + t.Logf("%s", err) + } +} + +func TestVarintError(t *testing.T) { + buf := newBuffer() + buf.Write([]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f}) + reader := io.NewDelimitedReader(buf, 1024*1024) + msg := &test.NinOptNative{} + err := reader.ReadMsg(msg) + if err == nil { + t.Fatalf("Expected error") + } +} + +func TestFull(t *testing.T) { + buf := newBuffer() + writer := io.NewFullWriter(buf) + reader := io.NewFullReader(buf, 1024*1024) + r := rand.New(rand.NewSource(time.Now().UnixNano())) + msgIn := test.NewPopulatedNinOptNative(r, true) + if err := writer.WriteMsg(msgIn); err != nil { + panic(err) + } + if err := writer.Close(); err != nil { + panic(err) + } + msgOut := &test.NinOptNative{} + if err := reader.ReadMsg(msgOut); err != nil { + panic(err) + } + if err := msgIn.VerboseEqual(msgOut); err != nil { + panic(err) + } + if err := reader.ReadMsg(msgOut); err != nil { + if err != goio.EOF { + panic(err) + } + } + if err := reader.Close(); err != nil { + panic(err) + } + if !buf.closed { + t.Fatalf("did not close buffer") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/io/uint32.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/io/uint32.go new file mode 100644 index 0000000000000000000000000000000000000000..425d648d64c1b52004dbd75d461ce7413813f1c6 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/io/uint32.go @@ -0,0 +1,120 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 io + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "encoding/binary" + "io" +) + +func NewUint32DelimitedWriter(w io.Writer, byteOrder binary.ByteOrder) WriteCloser { + return &uint32Writer{w, byteOrder, nil} +} + +func NewSizeUint32DelimitedWriter(w io.Writer, byteOrder binary.ByteOrder, size int) WriteCloser { + return &uint32Writer{w, byteOrder, make([]byte, size)} +} + +type uint32Writer struct { + w io.Writer + byteOrder binary.ByteOrder + buffer []byte +} + +func (this *uint32Writer) WriteMsg(msg proto.Message) (err error) { + var data []byte + if m, ok := msg.(marshaler); ok { + n := m.Size() + if n >= len(this.buffer) { + this.buffer = make([]byte, n) + } + _, err = m.MarshalTo(this.buffer) + if err != nil { + return err + } + data = this.buffer[:n] + } else { + data, err = proto.Marshal(msg) + if err != nil { + return err + } + } + length := uint32(len(data)) + if err := binary.Write(this.w, this.byteOrder, &length); err != nil { + return err + } + _, err = this.w.Write(data) + return err +} + +func (this *uint32Writer) Close() error { + if closer, ok := this.w.(io.Closer); ok { + return closer.Close() + } + return nil +} + +type uint32Reader struct { + r io.Reader + byteOrder binary.ByteOrder + lenBuf []byte + buf []byte + maxSize int +} + +func NewUint32DelimitedReader(r io.Reader, byteOrder binary.ByteOrder, maxSize int) ReadCloser { + return &uint32Reader{r, byteOrder, make([]byte, 4), nil, maxSize} +} + +func (this *uint32Reader) ReadMsg(msg proto.Message) error { + if _, err := io.ReadFull(this.r, this.lenBuf); err != nil { + return err + } + length32 := this.byteOrder.Uint32(this.lenBuf) + length := int(length32) + if length < 0 || length > this.maxSize { + return io.ErrShortBuffer + } + if length >= len(this.buf) { + this.buf = make([]byte, length) + } + _, err := io.ReadFull(this.r, this.buf[:length]) + if err != nil { + return err + } + return proto.Unmarshal(this.buf[:length], msg) +} + +func (this *uint32Reader) Close() error { + if closer, ok := this.r.(io.Closer); ok { + return closer.Close() + } + return nil +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/io/varint.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/io/varint.go new file mode 100644 index 0000000000000000000000000000000000000000..c8b3349d7d17e14faf6dc25304a0fb034f2cf5f5 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/io/varint.go @@ -0,0 +1,128 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 io + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "bufio" + "encoding/binary" + "errors" + "io" +) + +var ( + errSmallBuffer = errors.New("Buffer Too Small") + errLargeValue = errors.New("Value is Larger than 64 bits") +) + +func NewDelimitedWriter(w io.Writer) WriteCloser { + return &varintWriter{w, make([]byte, 10), nil} +} + +type varintWriter struct { + w io.Writer + lenBuf []byte + buffer []byte +} + +func (this *varintWriter) WriteMsg(msg proto.Message) (err error) { + var data []byte + if m, ok := msg.(marshaler); ok { + n := m.Size() + if n >= len(this.buffer) { + this.buffer = make([]byte, n) + } + _, err = m.MarshalTo(this.buffer) + if err != nil { + return err + } + data = this.buffer[:n] + } else { + data, err = proto.Marshal(msg) + if err != nil { + return err + } + } + length := uint64(len(data)) + n := binary.PutUvarint(this.lenBuf, length) + _, err = this.w.Write(this.lenBuf[:n]) + if err != nil { + return err + } + _, err = this.w.Write(data) + return err +} + +func (this *varintWriter) Close() error { + if closer, ok := this.w.(io.Closer); ok { + return closer.Close() + } + return nil +} + +func NewDelimitedReader(r io.Reader, maxSize int) ReadCloser { + var closer io.Closer + if c, ok := r.(io.Closer); ok { + closer = c + } + return &varintReader{bufio.NewReader(r), nil, maxSize, closer} +} + +type varintReader struct { + r *bufio.Reader + buf []byte + maxSize int + closer io.Closer +} + +func (this *varintReader) ReadMsg(msg proto.Message) error { + length64, err := binary.ReadUvarint(this.r) + if err != nil { + return err + } + length := int(length64) + if length < 0 || length > this.maxSize { + return io.ErrShortBuffer + } + if len(this.buf) < length { + this.buf = make([]byte, length) + } + buf := this.buf[:length] + if _, err := io.ReadFull(this.r, buf); err != nil { + return err + } + return proto.Unmarshal(buf, msg) +} + +func (this *varintReader) Close() error { + if this.closer != nil { + return this.closer.Close() + } + return nil +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb.go new file mode 100644 index 0000000000000000000000000000000000000000..72449bc096ee05507a53a43d73b2202e788a2426 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb.go @@ -0,0 +1,449 @@ +// 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 provides marshaling/unmarshaling functionality between +protocol buffer and JSON objects. + +Compared to encoding/json, this library: + - encodes int64, uint64 as strings + - optionally encodes enums as strings +*/ +package jsonpb + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "reflect" + "sort" + "strconv" + "strings" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +) + +var ( + byteArrayType = reflect.TypeOf([]byte{}) +) + +// Marshaler is a configurable object for converting between +// protocol buffer objects and a JSON representation for them +type Marshaler struct { + // Use string values for enums (as opposed to integer values) + EnumsAsString bool + + // A string to indent each level by. The presence of this field will + // also cause a space to appear between the field separator and + // value, and for newlines to be appear between fields and array + // elements. + Indent string +} + +// Marshal marshals a protocol buffer into JSON. +func (m *Marshaler) Marshal(out io.Writer, pb proto.Message) error { + writer := &errWriter{writer: out} + return m.marshalObject(writer, pb, "") +} + +// MarshalToString converts a protocol buffer object to JSON string. +func (m *Marshaler) MarshalToString(pb proto.Message) (string, error) { + var buf bytes.Buffer + if err := m.Marshal(&buf, pb); err != nil { + return "", err + } + return buf.String(), nil +} + +// marshalObject writes a struct to the Writer. +func (m *Marshaler) marshalObject(out *errWriter, v proto.Message, indent string) error { + out.write("{") + if m.Indent != "" { + out.write("\n") + } + + s := reflect.ValueOf(v).Elem() + writeBeforeField := "" + for i := 0; i < s.NumField(); i++ { + value := s.Field(i) + valueField := s.Type().Field(i) + if strings.HasPrefix(valueField.Name, "XXX_") { + continue + } + fieldName := jsonFieldName(valueField) + + // TODO: proto3 objects should have default values omitted. + + // IsNil will panic on most value kinds. + switch value.Kind() { + case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: + if value.IsNil() { + continue + } + } + + // Oneof fields need special handling. + if valueField.Tag.Get("protobuf_oneof") != "" { + // value is an interface containing &T{real_value}. + sv := value.Elem().Elem() // interface -> *T -> T + value = sv.Field(0) + valueField = sv.Type().Field(0) + + var p proto.Properties + p.Parse(sv.Type().Field(0).Tag.Get("protobuf")) + fieldName = p.OrigName + } + + out.write(writeBeforeField) + if m.Indent != "" { + out.write(indent) + out.write(m.Indent) + } + out.write(`"`) + out.write(fieldName) + out.write(`":`) + if m.Indent != "" { + out.write(" ") + } + + if err := m.marshalValue(out, value, valueField, indent); err != nil { + return err + } + + if m.Indent != "" { + writeBeforeField = ",\n" + } else { + writeBeforeField = "," + } + } + + if m.Indent != "" { + out.write("\n") + out.write(indent) + } + out.write("}") + return out.err +} + +// marshalValue writes the value to the Writer. +func (m *Marshaler) marshalValue(out *errWriter, v reflect.Value, + structField reflect.StructField, indent string) error { + + v = reflect.Indirect(v) + + // Handle repeated elements. + if v.Type() != byteArrayType && v.Kind() == reflect.Slice { + out.write("[") + comma := "" + for i := 0; i < v.Len(); i++ { + sliceVal := v.Index(i) + out.write(comma) + if m.Indent != "" { + out.write("\n") + out.write(indent) + out.write(m.Indent) + out.write(m.Indent) + } + m.marshalValue(out, sliceVal, structField, indent+m.Indent) + comma = "," + } + if m.Indent != "" { + out.write("\n") + out.write(indent) + out.write(m.Indent) + } + out.write("]") + return out.err + } + + // Handle enumerations. + protoInfo := structField.Tag.Get("protobuf") + if m.EnumsAsString && strings.Contains(protoInfo, ",enum=") { + // Unknown enum values will are stringified by the proto library as their + // value. Such values should _not_ be quoted or they will be intrepreted + // as an enum string instead of their value. + enumStr := v.Interface().(fmt.Stringer).String() + var valStr string + if v.Kind() == reflect.Ptr { + valStr = strconv.Itoa(int(v.Elem().Int())) + } else { + valStr = strconv.Itoa(int(v.Int())) + } + isKnownEnum := enumStr != valStr + if isKnownEnum { + out.write(`"`) + } + out.write(enumStr) + if isKnownEnum { + out.write(`"`) + } + return out.err + } + + // Handle nested messages. + if v.Kind() == reflect.Struct { + return m.marshalObject(out, v.Addr().Interface().(proto.Message), indent+m.Indent) + } + + // Handle maps. + // Since Go randomizes map iteration, we sort keys for stable output. + if v.Kind() == reflect.Map { + out.write(`{`) + keys := v.MapKeys() + sort.Sort(mapKeys(keys)) + for i, k := range keys { + if i > 0 { + out.write(`,`) + } + if m.Indent != "" { + out.write("\n") + out.write(indent) + out.write(m.Indent) + out.write(m.Indent) + } + + b, err := json.Marshal(k.Interface()) + if err != nil { + return err + } + s := string(b) + + // If the JSON is not a string value, encode it again to make it one. + if !strings.HasPrefix(s, `"`) { + b, err := json.Marshal(s) + if err != nil { + return err + } + s = string(b) + } + + out.write(s) + out.write(`:`) + if m.Indent != "" { + out.write(` `) + } + + if err := m.marshalValue(out, v.MapIndex(k), structField, indent+m.Indent); err != nil { + return err + } + } + if m.Indent != "" { + out.write("\n") + out.write(indent) + out.write(m.Indent) + } + out.write(`}`) + return out.err + } + + // Default handling defers to the encoding/json library. + b, err := json.Marshal(v.Interface()) + if err != nil { + return err + } + needToQuote := string(b[0]) != `"` && (v.Kind() == reflect.Int64 || v.Kind() == reflect.Uint64) + if needToQuote { + out.write(`"`) + } + out.write(string(b)) + if needToQuote { + out.write(`"`) + } + return out.err +} + +// Unmarshal unmarshals a JSON object stream into a protocol +// buffer. This function is lenient and will decode any options +// permutations of the related Marshaler. +func Unmarshal(r io.Reader, pb proto.Message) error { + inputValue := json.RawMessage{} + if err := json.NewDecoder(r).Decode(&inputValue); err != nil { + return err + } + return unmarshalValue(reflect.ValueOf(pb).Elem(), inputValue) +} + +// UnmarshalString will populate the fields of a protocol buffer based +// on a JSON string. This function is lenient and will decode any options +// permutations of the related Marshaler. +func UnmarshalString(str string, pb proto.Message) error { + return Unmarshal(bytes.NewReader([]byte(str)), pb) +} + +// unmarshalValue converts/copies a value into the target. +func unmarshalValue(target reflect.Value, inputValue json.RawMessage) error { + targetType := target.Type() + + // Allocate memory for pointer fields. + if targetType.Kind() == reflect.Ptr { + target.Set(reflect.New(targetType.Elem())) + return unmarshalValue(target.Elem(), inputValue) + } + + // Handle nested messages. + if targetType.Kind() == reflect.Struct { + var jsonFields map[string]json.RawMessage + if err := json.Unmarshal(inputValue, &jsonFields); err != nil { + return err + } + + for i := 0; i < target.NumField(); i++ { + ft := target.Type().Field(i) + if strings.HasPrefix(ft.Name, "XXX_") { + continue + } + fieldName := jsonFieldName(ft) + + if valueForField, ok := jsonFields[fieldName]; ok { + if err := unmarshalValue(target.Field(i), valueForField); err != nil { + return err + } + delete(jsonFields, fieldName) + } + } + // Check for any oneof fields. + sprops := proto.GetProperties(targetType) + for fname, raw := range jsonFields { + if oop, ok := sprops.OneofTypes[fname]; ok { + nv := reflect.New(oop.Type.Elem()) + target.Field(oop.Field).Set(nv) + if err := unmarshalValue(nv.Elem().Field(0), raw); err != nil { + return err + } + delete(jsonFields, fname) + } + } + if len(jsonFields) > 0 { + // Pick any field to be the scapegoat. + var f string + for fname := range jsonFields { + f = fname + break + } + return fmt.Errorf("unknown field %q in %v", f, targetType) + } + return nil + } + + // Handle arrays (which aren't encoded bytes) + if targetType != byteArrayType && targetType.Kind() == reflect.Slice { + var slc []json.RawMessage + 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 := unmarshalValue(target.Index(i), slc[i]); err != nil { + return err + } + } + return nil + } + + // Handle maps (whose keys are always strings) + if targetType.Kind() == reflect.Map { + var mp map[string]json.RawMessage + if err := json.Unmarshal(inputValue, &mp); err != nil { + return err + } + target.Set(reflect.MakeMap(targetType)) + 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 := unmarshalValue(k, json.RawMessage(ks)); err != nil { + return err + } + } + + // Unmarshal map value. + v := reflect.New(targetType.Elem()).Elem() + if err := unmarshalValue(v, raw); err != nil { + return err + } + target.SetMapIndex(k, v) + } + return nil + } + + // 64-bit integers can be encoded as strings. In this case we drop + // the quotes and proceed as normal. + isNum := targetType.Kind() == reflect.Int64 || targetType.Kind() == reflect.Uint64 + if isNum && strings.HasPrefix(string(inputValue), `"`) { + inputValue = inputValue[1 : len(inputValue)-1] + } + + // Use the encoding/json for parsing other value types. + return json.Unmarshal(inputValue, target.Addr().Interface()) +} + +// hasUnmarshalJSON is a interface implemented by protocol buffer enums. +type hasUnmarshalJSON interface { + UnmarshalJSON(data []byte) error +} + +// jsonFieldName returns the field name to use. +func jsonFieldName(f reflect.StructField) string { + var prop proto.Properties + prop.Init(f.Type, f.Name, f.Tag.Get("protobuf"), &f) + return prop.OrigName +} + +// Writer wrapper inspired by https://blog.golang.org/errors-are-values +type errWriter struct { + writer io.Writer + err error +} + +func (w *errWriter) write(str string) { + if w.err != nil { + return + } + _, w.err = w.writer.Write([]byte(str)) +} + +// Map fields may have key types of non-float scalars, strings and enums. +// The easiest way to sort them in some deterministic order is to use fmt. +// If this turns out to be inefficient we can always consider other options, +// such as doing a Schwartzian transform. +type mapKeys []reflect.Value + +func (s mapKeys) Len() int { return len(s) } +func (s mapKeys) Swap(i, j int) { s[i], s[j] = s[j], s[i] } +func (s mapKeys) Less(i, j int) bool { + return fmt.Sprint(s[i].Interface()) < fmt.Sprint(s[j].Interface()) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..947c835f5d6601ad170a8010cdbca063bd54ef40 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test.go @@ -0,0 +1,370 @@ +// 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 ( + "reflect" + "testing" + + pb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test_proto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +) + +var ( + marshaler = Marshaler{} + + marshalerAllOptions = Marshaler{ + EnumsAsString: true, + 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"), + } + + simpleObjectJSON = `{` + + `"o_bool":true,` + + `"o_int32":-32,` + + `"o_int64":"-6400000000",` + + `"o_uint32":32,` + + `"o_uint64":"6400000000",` + + `"o_sint32":-13,` + + `"o_sint64":"-2600000000",` + + `"o_float":3.14,` + + `"o_double":6.02214179e+23,` + + `"o_string":"hello \"there\"",` + + `"o_bytes":"YmVlcCBib29w"` + + `}` + + simpleObjectPrettyJSON = `{ + "o_bool": true, + "o_int32": -32, + "o_int64": "-6400000000", + "o_uint32": 32, + "o_uint64": "6400000000", + "o_sint32": -13, + "o_sint64": "-2600000000", + "o_float": 3.14, + "o_double": 6.02214179e+23, + "o_string": "hello \"there\"", + "o_bytes": "YmVlcCBib29w" +}` + + 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, 6.62606957e-34}, + RString: []string{"happy", "days"}, + RBytes: [][]byte{[]byte("skittles"), []byte("m&m's")}, + } + + repeatsObjectJSON = `{` + + `"r_bool":[true,false,true],` + + `"r_int32":[-3,-4,-5],` + + `"r_int64":["-123456789","-987654321"],` + + `"r_uint32":[1,2,3],` + + `"r_uint64":["6789012345","3456789012"],` + + `"r_sint32":[-1,-2,-3],` + + `"r_sint64":["-6789012345","-3456789012"],` + + `"r_float":[3.14,6.28],` + + `"r_double":[2.99792458e+08,6.62606957e-34],` + + `"r_string":["happy","days"],` + + `"r_bytes":["c2tpdHRsZXM=","bSZtJ3M="]` + + `}` + + repeatsObjectPrettyJSON = `{ + "r_bool": [ + true, + false, + true + ], + "r_int32": [ + -3, + -4, + -5 + ], + "r_int64": [ + "-123456789", + "-987654321" + ], + "r_uint32": [ + 1, + 2, + 3 + ], + "r_uint64": [ + "6789012345", + "3456789012" + ], + "r_sint32": [ + -1, + -2, + -3 + ], + "r_sint64": [ + "-6789012345", + "-3456789012" + ], + "r_float": [ + 3.14, + 6.28 + ], + "r_double": [ + 2.99792458e+08, + 6.62606957e-34 + ], + "r_string": [ + "happy", + "days" + ], + "r_bytes": [ + "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":1,` + + `"r_color":[0,1,2],` + + `"simple":{"o_int32":-32},` + + `"r_simple":[{"o_int32":-32},{"o_int64":"25"}],` + + `"repeats":{"r_string":["roses","red"]},` + + `"r_repeats":[{"r_string":["roses","red"]},{"r_string":["violets","blue"]}]` + + `}` + + complexObjectPrettyJSON = `{ + "color": "GREEN", + "r_color": [ + "RED", + "GREEN", + "BLUE" + ], + "simple": { + "o_int32": -32 + }, + "r_simple": [ + { + "o_int32": -32 + }, + { + "o_int64": "25" + } + ], + "repeats": { + "r_string": [ + "roses", + "red" + ] + }, + "r_repeats": [ + { + "r_string": [ + "roses", + "red" + ] + }, + { + "r_string": [ + "violets", + "blue" + ] + } + ] +}` + + colorPrettyJSON = `{ + "color": 2 +}` + + colorListPrettyJSON = `{ + "color": 1000, + "r_color": [ + "RED" + ] +}` + + nummyPrettyJSON = `{ + "nummy": { + "1": 2, + "3": 4 + } +}` + + objjyPrettyJSON = `{ + "objjy": { + "1": { + "dub": 1 + } + } +}` +) + +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{EnumsAsString: true}, + &pb.Widget{Color: pb.Widget_BLUE.Enum()}, `{"color":"BLUE"}`}, + {"enum-value pretty object", Marshaler{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}, + {"proto3 object with empty value", marshaler, &pb.Simple3{}, `{"dub":0}`}, + {"map", marshaler, &pb.Mappy{Nummy: map[int64]int32{1: 2, 3: 4}}, `{"nummy":{"1":2,"3":4}}`}, + {"map", marshalerAllOptions, &pb.Mappy{Nummy: map[int64]int32{1: 2, 3: 4}}, nummyPrettyJSON}, + {"map", marshaler, + &pb.Mappy{Strry: map[string]string{`"one"`: "two", "three": "four"}}, + `{"strry":{"\"one\"":"two","three":"four"}}`}, + {"map", marshaler, + &pb.Mappy{Objjy: map[int32]*pb.Simple3{1: {Dub: 1}}}, `{"objjy":{"1":{"dub":1}}}`}, + {"map", marshalerAllOptions, + &pb.Mappy{Objjy: map[int32]*pb.Simple3{1: {Dub: 1}}}, objjyPrettyJSON}, + {"map", marshaler, &pb.Mappy{Buggy: map[int64]string{1234: "yup"}}, + `{"buggy":{"1234":"yup"}}`}, + {"map", marshaler, &pb.Mappy{Booly: map[bool]bool{false: true}}, `{"booly":{"false":true}}`}, + {"proto2 map", marshaler, &pb.Maps{MInt64Str: map[int64]string{213: "cat"}}, + `{"m_int64_str":{"213":"cat"}}`}, + {"proto2 map", marshaler, + &pb.Maps{MBoolSimple: map[bool]*pb.Simple{true: {OInt32: proto.Int32(1)}}}, + `{"m_bool_simple":{"true":{"o_int32":1}}}`}, + {"oneof, not set", marshaler, &pb.MsgWithOneof{}, `{}`}, + {"oneof, set", marshaler, &pb.MsgWithOneof{Union: &pb.MsgWithOneof_Title{Title: "Grand Poobah"}}, `{"title":"Grand Poobah"}`}, +} + +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) + } + } +} + +var unmarshalingTests = []struct { + desc string + json string + pb proto.Message +}{ + {"simple flat object", simpleObjectJSON, simpleObject}, + {"simple pretty object", simpleObjectPrettyJSON, simpleObject}, + {"repeated fields flat object", repeatsObjectJSON, repeatsObject}, + {"repeated fields pretty object", repeatsObjectPrettyJSON, repeatsObject}, + {"nested message/enum flat object", complexObjectJSON, complexObject}, + {"nested message/enum pretty object", complexObjectPrettyJSON, complexObject}, + {"enum-string object", `{"color":"BLUE"}`, &pb.Widget{Color: pb.Widget_BLUE.Enum()}}, + {"enum-value object", "{\n \"color\": 2\n}", &pb.Widget{Color: pb.Widget_BLUE.Enum()}}, + {"unknown enum value object", + "{\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}}}, + {"unquoted int64 object", `{"o_int64":-314}`, &pb.Simple{OInt64: proto.Int64(-314)}}, + {"unquoted uint64 object", `{"o_uint64":123}`, &pb.Simple{OUint64: proto.Uint64(123)}}, + {"map", `{"nummy":{"1":2,"3":4}}`, &pb.Mappy{Nummy: map[int64]int32{1: 2, 3: 4}}}, + {"map", `{"strry":{"\"one\"":"two","three":"four"}}`, &pb.Mappy{Strry: map[string]string{`"one"`: "two", "three": "four"}}}, + {"map", `{"objjy":{"1":{"dub":1}}}`, &pb.Mappy{Objjy: map[int32]*pb.Simple3{1: {Dub: 1}}}}, + {"oneof", `{"salary":31000}`, &pb.MsgWithOneof{Union: &pb.MsgWithOneof_Salary{Salary: 31000}}}, +} + +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 := UnmarshalString(tt.json, p) + if err != nil { + t.Error(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) + } + } +} + +var unmarshalingShouldError = []struct { + desc string + in string +}{ + {"a value", "666"}, + {"gibberish", "{adskja123;l23=-="}, +} + +func TestUnmarshalingBadInput(t *testing.T) { + for _, tt := range unmarshalingShouldError { + obj := &pb.Simple{} + err := UnmarshalString(tt.in, obj) + if err == nil { + t.Errorf("an error was expected when parsing %q instead of an object", tt.desc) + } + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test_proto/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test_proto/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..395c3add2326d3fd35db38530c21250c739c89f9 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test_proto/Makefile @@ -0,0 +1,33 @@ +# 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=. *.proto diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test_proto/more_test_objects.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test_proto/more_test_objects.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..c32425ab386647238b761fd775734d26f6c6658d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test_proto/more_test_objects.pb.go @@ -0,0 +1,85 @@ +// Code generated by protoc-gen-gogo. +// source: more_test_objects.proto +// DO NOT EDIT! + +/* +Package jsonpb is a generated protocol buffer package. + +It is generated from these files: + more_test_objects.proto + test_objects.proto + +It has these top-level messages: + Simple3 + Mappy + Simple + Repeats + Widget + Maps + MsgWithOneof +*/ +package jsonpb + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Simple3 struct { + Dub float64 `protobuf:"fixed64,1,opt,name=dub,proto3" json:"dub,omitempty"` +} + +func (m *Simple3) Reset() { *m = Simple3{} } +func (m *Simple3) String() string { return proto.CompactTextString(m) } +func (*Simple3) ProtoMessage() {} + +type Mappy struct { + Nummy map[int64]int32 `protobuf:"bytes,1,rep,name=nummy" json:"nummy,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Strry map[string]string `protobuf:"bytes,2,rep,name=strry" json:"strry,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + Objjy map[int32]*Simple3 `protobuf:"bytes,3,rep,name=objjy" json:"objjy,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` + Buggy map[int64]string `protobuf:"bytes,4,rep,name=buggy" json:"buggy,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + Booly map[bool]bool `protobuf:"bytes,5,rep,name=booly" json:"booly,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` +} + +func (m *Mappy) Reset() { *m = Mappy{} } +func (m *Mappy) String() string { return proto.CompactTextString(m) } +func (*Mappy) ProtoMessage() {} + +func (m *Mappy) GetNummy() map[int64]int32 { + if m != nil { + return m.Nummy + } + return nil +} + +func (m *Mappy) GetStrry() map[string]string { + if m != nil { + return m.Strry + } + return nil +} + +func (m *Mappy) GetObjjy() map[int32]*Simple3 { + if m != nil { + return m.Objjy + } + return nil +} + +func (m *Mappy) GetBuggy() map[int64]string { + if m != nil { + return m.Buggy + } + return nil +} + +func (m *Mappy) GetBooly() map[bool]bool { + if m != nil { + return m.Booly + } + return nil +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test_proto/more_test_objects.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test_proto/more_test_objects.proto new file mode 100644 index 0000000000000000000000000000000000000000..65357916329d37513e40352202fa80763641977c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test_proto/more_test_objects.proto @@ -0,0 +1,46 @@ +// 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 Mappy { + map nummy = 1; + map strry = 2; + map objjy = 3; + map buggy = 4; + map booly = 5; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test_proto/test_objects.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test_proto/test_objects.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..5cf41f74ca760cea3dffeb247d17416692a2d82b --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test_proto/test_objects.pb.go @@ -0,0 +1,423 @@ +// Code generated by protoc-gen-gogo. +// source: test_objects.proto +// DO NOT EDIT! + +package jsonpb + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Widget_Color int32 + +const ( + Widget_RED Widget_Color = 0 + Widget_GREEN Widget_Color = 1 + Widget_BLUE Widget_Color = 2 +) + +var Widget_Color_name = map[int32]string{ + 0: "RED", + 1: "GREEN", + 2: "BLUE", +} +var Widget_Color_value = map[string]int32{ + "RED": 0, + "GREEN": 1, + "BLUE": 2, +} + +func (x Widget_Color) Enum() *Widget_Color { + p := new(Widget_Color) + *p = x + return p +} +func (x Widget_Color) String() string { + return proto.EnumName(Widget_Color_name, int32(x)) +} +func (x *Widget_Color) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Widget_Color_value, data, "Widget_Color") + if err != nil { + return err + } + *x = Widget_Color(value) + return nil +} + +// Test message for holding primitive types. +type Simple struct { + OBool *bool `protobuf:"varint,1,opt,name=o_bool" json:"o_bool,omitempty"` + OInt32 *int32 `protobuf:"varint,2,opt,name=o_int32" json:"o_int32,omitempty"` + OInt64 *int64 `protobuf:"varint,3,opt,name=o_int64" json:"o_int64,omitempty"` + OUint32 *uint32 `protobuf:"varint,4,opt,name=o_uint32" json:"o_uint32,omitempty"` + OUint64 *uint64 `protobuf:"varint,5,opt,name=o_uint64" json:"o_uint64,omitempty"` + OSint32 *int32 `protobuf:"zigzag32,6,opt,name=o_sint32" json:"o_sint32,omitempty"` + OSint64 *int64 `protobuf:"zigzag64,7,opt,name=o_sint64" json:"o_sint64,omitempty"` + OFloat *float32 `protobuf:"fixed32,8,opt,name=o_float" json:"o_float,omitempty"` + ODouble *float64 `protobuf:"fixed64,9,opt,name=o_double" json:"o_double,omitempty"` + OString *string `protobuf:"bytes,10,opt,name=o_string" json:"o_string,omitempty"` + OBytes []byte `protobuf:"bytes,11,opt,name=o_bytes" json:"o_bytes,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Simple) Reset() { *m = Simple{} } +func (m *Simple) String() string { return proto.CompactTextString(m) } +func (*Simple) ProtoMessage() {} + +func (m *Simple) GetOBool() bool { + if m != nil && m.OBool != nil { + return *m.OBool + } + return false +} + +func (m *Simple) GetOInt32() int32 { + if m != nil && m.OInt32 != nil { + return *m.OInt32 + } + return 0 +} + +func (m *Simple) GetOInt64() int64 { + if m != nil && m.OInt64 != nil { + return *m.OInt64 + } + return 0 +} + +func (m *Simple) GetOUint32() uint32 { + if m != nil && m.OUint32 != nil { + return *m.OUint32 + } + return 0 +} + +func (m *Simple) GetOUint64() uint64 { + if m != nil && m.OUint64 != nil { + return *m.OUint64 + } + return 0 +} + +func (m *Simple) GetOSint32() int32 { + if m != nil && m.OSint32 != nil { + return *m.OSint32 + } + return 0 +} + +func (m *Simple) GetOSint64() int64 { + if m != nil && m.OSint64 != nil { + return *m.OSint64 + } + return 0 +} + +func (m *Simple) GetOFloat() float32 { + if m != nil && m.OFloat != nil { + return *m.OFloat + } + return 0 +} + +func (m *Simple) GetODouble() float64 { + if m != nil && m.ODouble != nil { + return *m.ODouble + } + return 0 +} + +func (m *Simple) GetOString() string { + if m != nil && m.OString != nil { + return *m.OString + } + return "" +} + +func (m *Simple) GetOBytes() []byte { + if m != nil { + return m.OBytes + } + return nil +} + +// Test message for holding repeated primitives. +type Repeats struct { + RBool []bool `protobuf:"varint,1,rep,name=r_bool" json:"r_bool,omitempty"` + RInt32 []int32 `protobuf:"varint,2,rep,name=r_int32" json:"r_int32,omitempty"` + RInt64 []int64 `protobuf:"varint,3,rep,name=r_int64" json:"r_int64,omitempty"` + RUint32 []uint32 `protobuf:"varint,4,rep,name=r_uint32" json:"r_uint32,omitempty"` + RUint64 []uint64 `protobuf:"varint,5,rep,name=r_uint64" json:"r_uint64,omitempty"` + RSint32 []int32 `protobuf:"zigzag32,6,rep,name=r_sint32" json:"r_sint32,omitempty"` + RSint64 []int64 `protobuf:"zigzag64,7,rep,name=r_sint64" json:"r_sint64,omitempty"` + RFloat []float32 `protobuf:"fixed32,8,rep,name=r_float" json:"r_float,omitempty"` + RDouble []float64 `protobuf:"fixed64,9,rep,name=r_double" json:"r_double,omitempty"` + RString []string `protobuf:"bytes,10,rep,name=r_string" json:"r_string,omitempty"` + RBytes [][]byte `protobuf:"bytes,11,rep,name=r_bytes" json:"r_bytes,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Repeats) Reset() { *m = Repeats{} } +func (m *Repeats) String() string { return proto.CompactTextString(m) } +func (*Repeats) ProtoMessage() {} + +func (m *Repeats) GetRBool() []bool { + if m != nil { + return m.RBool + } + return nil +} + +func (m *Repeats) GetRInt32() []int32 { + if m != nil { + return m.RInt32 + } + return nil +} + +func (m *Repeats) GetRInt64() []int64 { + if m != nil { + return m.RInt64 + } + return nil +} + +func (m *Repeats) GetRUint32() []uint32 { + if m != nil { + return m.RUint32 + } + return nil +} + +func (m *Repeats) GetRUint64() []uint64 { + if m != nil { + return m.RUint64 + } + return nil +} + +func (m *Repeats) GetRSint32() []int32 { + if m != nil { + return m.RSint32 + } + return nil +} + +func (m *Repeats) GetRSint64() []int64 { + if m != nil { + return m.RSint64 + } + return nil +} + +func (m *Repeats) GetRFloat() []float32 { + if m != nil { + return m.RFloat + } + return nil +} + +func (m *Repeats) GetRDouble() []float64 { + if m != nil { + return m.RDouble + } + return nil +} + +func (m *Repeats) GetRString() []string { + if m != nil { + return m.RString + } + return nil +} + +func (m *Repeats) GetRBytes() [][]byte { + if m != nil { + return m.RBytes + } + return nil +} + +// Test message for holding enums and nested messages. +type Widget struct { + Color *Widget_Color `protobuf:"varint,1,opt,name=color,enum=jsonpb.Widget_Color" json:"color,omitempty"` + RColor []Widget_Color `protobuf:"varint,2,rep,name=r_color,enum=jsonpb.Widget_Color" json:"r_color,omitempty"` + Simple *Simple `protobuf:"bytes,10,opt,name=simple" json:"simple,omitempty"` + RSimple []*Simple `protobuf:"bytes,11,rep,name=r_simple" json:"r_simple,omitempty"` + Repeats *Repeats `protobuf:"bytes,20,opt,name=repeats" json:"repeats,omitempty"` + RRepeats []*Repeats `protobuf:"bytes,21,rep,name=r_repeats" json:"r_repeats,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Widget) Reset() { *m = Widget{} } +func (m *Widget) String() string { return proto.CompactTextString(m) } +func (*Widget) ProtoMessage() {} + +func (m *Widget) GetColor() Widget_Color { + if m != nil && m.Color != nil { + return *m.Color + } + return Widget_RED +} + +func (m *Widget) GetRColor() []Widget_Color { + if m != nil { + return m.RColor + } + return nil +} + +func (m *Widget) GetSimple() *Simple { + if m != nil { + return m.Simple + } + return nil +} + +func (m *Widget) GetRSimple() []*Simple { + if m != nil { + return m.RSimple + } + return nil +} + +func (m *Widget) GetRepeats() *Repeats { + if m != nil { + return m.Repeats + } + return nil +} + +func (m *Widget) GetRRepeats() []*Repeats { + if m != nil { + return m.RRepeats + } + return nil +} + +type Maps struct { + MInt64Str map[int64]string `protobuf:"bytes,1,rep,name=m_int64_str" json:"m_int64_str,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + MBoolSimple map[bool]*Simple `protobuf:"bytes,2,rep,name=m_bool_simple" json:"m_bool_simple,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Maps) Reset() { *m = Maps{} } +func (m *Maps) String() string { return proto.CompactTextString(m) } +func (*Maps) ProtoMessage() {} + +func (m *Maps) GetMInt64Str() map[int64]string { + if m != nil { + return m.MInt64Str + } + return nil +} + +func (m *Maps) GetMBoolSimple() map[bool]*Simple { + if m != nil { + return m.MBoolSimple + } + return nil +} + +type MsgWithOneof struct { + // Types that are valid to be assigned to Union: + // *MsgWithOneof_Title + // *MsgWithOneof_Salary + Union isMsgWithOneof_Union `protobuf_oneof:"union"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MsgWithOneof) Reset() { *m = MsgWithOneof{} } +func (m *MsgWithOneof) String() string { return proto.CompactTextString(m) } +func (*MsgWithOneof) ProtoMessage() {} + +type isMsgWithOneof_Union interface { + isMsgWithOneof_Union() +} + +type MsgWithOneof_Title struct { + Title string `protobuf:"bytes,1,opt,name=title,oneof"` +} +type MsgWithOneof_Salary struct { + Salary int64 `protobuf:"varint,2,opt,name=salary,oneof"` +} + +func (*MsgWithOneof_Title) isMsgWithOneof_Union() {} +func (*MsgWithOneof_Salary) isMsgWithOneof_Union() {} + +func (m *MsgWithOneof) GetUnion() isMsgWithOneof_Union { + if m != nil { + return m.Union + } + return nil +} + +func (m *MsgWithOneof) GetTitle() string { + if x, ok := m.GetUnion().(*MsgWithOneof_Title); ok { + return x.Title + } + return "" +} + +func (m *MsgWithOneof) GetSalary() int64 { + if x, ok := m.GetUnion().(*MsgWithOneof_Salary); ok { + return x.Salary + } + return 0 +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*MsgWithOneof) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _MsgWithOneof_OneofMarshaler, _MsgWithOneof_OneofUnmarshaler, []interface{}{ + (*MsgWithOneof_Title)(nil), + (*MsgWithOneof_Salary)(nil), + } +} + +func _MsgWithOneof_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*MsgWithOneof) + // union + switch x := m.Union.(type) { + case *MsgWithOneof_Title: + _ = b.EncodeVarint(1<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Title) + case *MsgWithOneof_Salary: + _ = b.EncodeVarint(2<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Salary)) + case nil: + default: + return fmt.Errorf("MsgWithOneof.Union has unexpected type %T", x) + } + return nil +} + +func _MsgWithOneof_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*MsgWithOneof) + switch tag { + case 1: // union.title + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Union = &MsgWithOneof_Title{x} + return true, err + case 2: // union.salary + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Union = &MsgWithOneof_Salary{int64(x)} + return true, err + default: + return false, nil + } +} + +func init() { + proto.RegisterEnum("jsonpb.Widget_Color", Widget_Color_name, Widget_Color_value) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test_proto/test_objects.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test_proto/test_objects.proto new file mode 100644 index 0000000000000000000000000000000000000000..85700bfabad0d969cd1037ff1243fb0ebd3aa89d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb/jsonpb_test_proto/test_objects.proto @@ -0,0 +1,93 @@ +// 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"; + +package jsonpb; + +// 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; +} + +// 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 m_int64_str = 1; + map m_bool_simple = 2; +} + +message MsgWithOneof { + oneof union { + string title = 1; + int64 salary = 2; + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/package.json b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/package.json new file mode 100644 index 0000000000000000000000000000000000000000..2a866672c403a2efc9e77ddf00c3b15299237be7 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/package.json @@ -0,0 +1,9 @@ +{ + "name": "gogo-protobuf", + "author": "whyrusleeping", + "version": "1.0.0", + "language": "go", + "gx": { + "dvcsimport": "github.com/gogo/protobuf" + } +} \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/defaultcheck/defaultcheck.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/defaultcheck/defaultcheck.go new file mode 100644 index 0000000000000000000000000000000000000000..ed9e0f72b5c6c63bb381b7bf53a102c8b706bfbe --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/defaultcheck/defaultcheck.go @@ -0,0 +1,131 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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. + +/* +The defaultcheck plugin is used to check whether nullable is not used incorrectly. +For instance: +An error is caused if a nullable field: + - has a default value, + - is an enum which does not start at zero, + - is used for an extension, + - is used for a native proto3 type, + - is used for a repeated native type. + +An error is also caused if a field with a default value is used in a message: + - which is a face. + - without getters. + +It is enabled by the following extensions: + + - nullable + +For incorrect usage of nullable with tests see: + + github.com/gogo/protobuf/test/nullableconflict + +*/ +package defaultcheck + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" + "fmt" + "os" +) + +type plugin struct { + *generator.Generator +} + +func NewPlugin() *plugin { + return &plugin{} +} + +func (p *plugin) Name() string { + return "defaultcheck" +} + +func (p *plugin) Init(g *generator.Generator) { + p.Generator = g +} + +func (p *plugin) Generate(file *generator.FileDescriptor) { + proto3 := gogoproto.IsProto3(file.FileDescriptorProto) + for _, msg := range file.Messages() { + getters := gogoproto.HasGoGetters(file.FileDescriptorProto, msg.DescriptorProto) + face := gogoproto.IsFace(file.FileDescriptorProto, msg.DescriptorProto) + for _, field := range msg.GetField() { + if len(field.GetDefaultValue()) > 0 { + if !getters { + fmt.Fprintf(os.Stderr, "ERROR: field %v.%v cannot have a default value and not have a getter method", generator.CamelCase(*msg.Name), generator.CamelCase(*field.Name)) + os.Exit(1) + } + if face { + fmt.Fprintf(os.Stderr, "ERROR: field %v.%v cannot have a default value be in a face", generator.CamelCase(*msg.Name), generator.CamelCase(*field.Name)) + os.Exit(1) + } + } + if gogoproto.IsNullable(field) { + continue + } + if len(field.GetDefaultValue()) > 0 { + fmt.Fprintf(os.Stderr, "ERROR: field %v.%v cannot be non-nullable and have a default value", generator.CamelCase(*msg.Name), generator.CamelCase(*field.Name)) + os.Exit(1) + } + if !field.IsMessage() && !gogoproto.IsCustomType(field) { + if field.IsRepeated() { + fmt.Fprintf(os.Stderr, "WARNING: field %v.%v is a repeated non-nullable native type, nullable=false has no effect\n", generator.CamelCase(*msg.Name), generator.CamelCase(*field.Name)) + } else if proto3 { + fmt.Fprintf(os.Stderr, "ERROR: field %v.%v is a native type and in proto3 syntax with nullable=false there exists conflicting implementations when encoding zero values", generator.CamelCase(*msg.Name), generator.CamelCase(*field.Name)) + os.Exit(1) + } + if field.IsBytes() { + fmt.Fprintf(os.Stderr, "WARNING: field %v.%v is a non-nullable bytes type, nullable=false has no effect\n", generator.CamelCase(*msg.Name), generator.CamelCase(*field.Name)) + } + } + if !field.IsEnum() { + continue + } + enum := p.ObjectNamed(field.GetTypeName()).(*generator.EnumDescriptor) + if len(enum.Value) == 0 || enum.Value[0].GetNumber() != 0 { + fmt.Fprintf(os.Stderr, "ERROR: field %v.%v cannot be non-nullable and be an enum type %v which does not start with zero", generator.CamelCase(*msg.Name), generator.CamelCase(*field.Name), enum.GetName()) + os.Exit(1) + } + } + } + for _, e := range file.GetExtension() { + if !gogoproto.IsNullable(e) { + fmt.Fprintf(os.Stderr, "ERROR: extended field %v cannot be nullable %v", generator.CamelCase(e.GetName()), generator.CamelCase(*e.Name)) + os.Exit(1) + } + } +} + +func (p *plugin) GenerateImports(*generator.FileDescriptor) {} + +func init() { + generator.RegisterPlugin(NewPlugin()) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/description/description.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/description/description.go new file mode 100644 index 0000000000000000000000000000000000000000..523a067cb66bb19bb3f893799573cc74177d08d3 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/description/description.go @@ -0,0 +1,148 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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. + +/* +The description (experimental) plugin generates a Description method for each message. +The Description method returns a populated google_protobuf.FileDescriptorSet struct. +This contains the description of the files used to generate this message. + +It is enabled by the following extensions: + + - description + - description_all + +The description plugin also generates a test given it is enabled using one of the following extensions: + + - testgen + - testgen_all + +Let us look at: + + github.com/gogo/protobuf/test/example/example.proto + +Btw all the output can be seen at: + + github.com/gogo/protobuf/test/example/* + +The following message: + + message B { + option (gogoproto.description) = true; + optional A A = 1 [(gogoproto.nullable) = false, (gogoproto.embed) = true]; + repeated bytes G = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; + } + +given to the description plugin, will generate the following code: + + func (this *B) Description() (desc *google_protobuf.FileDescriptorSet) { + return ExampleDescription() + } + +and the following test code: + + func TestDescription(t *testing9.T) { + ExampleDescription() + } + +The hope is to use this struct in some way instead of reflect. +This package is subject to change, since a use has not been figured out yet. + +*/ +package description + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + descriptor "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" + "fmt" +) + +type plugin struct { + *generator.Generator + used bool +} + +func NewPlugin() *plugin { + return &plugin{} +} + +func (p *plugin) Name() string { + return "description" +} + +func (p *plugin) Init(g *generator.Generator) { + p.Generator = g +} + +func (p *plugin) Generate(file *generator.FileDescriptor) { + p.used = false + localName := generator.FileName(file) + for _, message := range file.Messages() { + if !gogoproto.HasDescription(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + p.used = true + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + p.P(`func (this *`, ccTypeName, `) Description() (desc *google_protobuf.FileDescriptorSet) {`) + p.In() + p.P(`return `, localName, `Description()`) + p.Out() + p.P(`}`) + } + + if p.used { + + p.P(`func `, localName, `Description() (desc *google_protobuf.FileDescriptorSet) {`) + p.In() + //Don't generate SourceCodeInfo, since it will create too much code. + + ss := make([]*descriptor.SourceCodeInfo, 0) + for _, f := range p.Generator.AllFiles().GetFile() { + ss = append(ss, f.SourceCodeInfo) + f.SourceCodeInfo = nil + } + s := fmt.Sprintf("%#v", p.Generator.AllFiles()) + for i, f := range p.Generator.AllFiles().GetFile() { + f.SourceCodeInfo = ss[i] + } + p.P(`return `, s) + p.Out() + p.P(`}`) + } +} + +func (this *plugin) GenerateImports(file *generator.FileDescriptor) { + if this.used { + this.P(`import google_protobuf "github.com/gogo/protobuf/protoc-gen-gogo/descriptor"`) + } +} + +func init() { + generator.RegisterPlugin(NewPlugin()) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/description/descriptiontest.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/description/descriptiontest.go new file mode 100644 index 0000000000000000000000000000000000000000..472df7809c97d777dbcd0b4e2fd34053e1a4724e --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/description/descriptiontest.go @@ -0,0 +1,71 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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 description + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/testgen" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" +) + +type test struct { + *generator.Generator +} + +func NewTest(g *generator.Generator) testgen.TestPlugin { + return &test{g} +} + +func (p *test) Generate(imports generator.PluginImports, file *generator.FileDescriptor) bool { + used := false + testingPkg := imports.NewImport("testing") + for _, message := range file.Messages() { + if !gogoproto.HasDescription(file.FileDescriptorProto, message.DescriptorProto) || + !gogoproto.HasTestGen(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + used = true + } + + if used { + localName := generator.FileName(file) + p.P(`func Test`, localName, `Description(t *`, testingPkg.Use(), `.T) {`) + p.In() + p.P(localName, `Description()`) + p.Out() + p.P(`}`) + + } + return used +} + +func init() { + testgen.RegisterTestPlugin(NewTest) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/embedcheck/embedcheck.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/embedcheck/embedcheck.go new file mode 100644 index 0000000000000000000000000000000000000000..fc45af57f1546fe061efe9f3ea2ffdab5c651513 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/embedcheck/embedcheck.go @@ -0,0 +1,196 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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. + +/* +The embedcheck plugin is used to check whether embed is not used incorrectly. +For instance: +An embedded message has a generated string method, but the is a member of a message which does not. +This causes a warning. +An error is caused by a namespace conflict. + +It is enabled by the following extensions: + + - embed + - embed_all + +For incorrect usage of embed with tests see: + + github.com/gogo/protobuf/test/embedconflict + +*/ +package embedcheck + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" + "fmt" + "os" +) + +type plugin struct { + *generator.Generator +} + +func NewPlugin() *plugin { + return &plugin{} +} + +func (p *plugin) Name() string { + return "embedcheck" +} + +func (p *plugin) Init(g *generator.Generator) { + p.Generator = g +} + +var overwriters []map[string]gogoproto.EnableFunc = []map[string]gogoproto.EnableFunc{ + { + "stringer": gogoproto.IsStringer, + }, + { + "gostring": gogoproto.HasGoString, + }, + { + "equal": gogoproto.HasEqual, + }, + { + "verboseequal": gogoproto.HasVerboseEqual, + }, + { + "size": gogoproto.IsSizer, + }, + { + "unmarshaler": gogoproto.IsUnmarshaler, + "unsafe_unmarshaler": gogoproto.IsUnsafeUnmarshaler, + }, + { + "marshaler": gogoproto.IsMarshaler, + "unsafe_marshaler": gogoproto.IsUnsafeMarshaler, + }, +} + +func (p *plugin) Generate(file *generator.FileDescriptor) { + for _, msg := range file.Messages() { + for _, os := range overwriters { + possible := true + for _, overwriter := range os { + if overwriter(file.FileDescriptorProto, msg.DescriptorProto) { + possible = false + } + } + if possible { + p.checkOverwrite(msg, os) + } + } + p.checkNameSpace(msg) + for _, field := range msg.GetField() { + if gogoproto.IsEmbed(field) && gogoproto.IsCustomName(field) { + fmt.Fprintf(os.Stderr, "ERROR: field %v with custom name %v cannot be embedded", *field.Name, gogoproto.GetCustomName(field)) + os.Exit(1) + } + } + p.checkRepeated(msg) + } + for _, e := range file.GetExtension() { + if gogoproto.IsEmbed(e) { + fmt.Fprintf(os.Stderr, "ERROR: extended field %v cannot be embedded", generator.CamelCase(*e.Name)) + os.Exit(1) + } + } +} + +func (p *plugin) checkNameSpace(message *generator.Descriptor) map[string]bool { + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + names := make(map[string]bool) + for _, field := range message.Field { + fieldname := generator.CamelCase(*field.Name) + if field.IsMessage() && gogoproto.IsEmbed(field) { + desc := p.ObjectNamed(field.GetTypeName()) + moreNames := p.checkNameSpace(desc.(*generator.Descriptor)) + for another := range moreNames { + if names[another] { + fmt.Fprintf(os.Stderr, "ERROR: duplicate embedded fieldname %v in type %v\n", fieldname, ccTypeName) + os.Exit(1) + } + names[another] = true + } + } else { + if names[fieldname] { + fmt.Fprintf(os.Stderr, "ERROR: duplicate embedded fieldname %v in type %v\n", fieldname, ccTypeName) + os.Exit(1) + } + names[fieldname] = true + } + } + return names +} + +func (p *plugin) checkOverwrite(message *generator.Descriptor, enablers map[string]gogoproto.EnableFunc) { + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + names := []string{} + for name := range enablers { + names = append(names, name) + } + for _, field := range message.Field { + if field.IsMessage() && gogoproto.IsEmbed(field) { + fieldname := generator.CamelCase(*field.Name) + desc := p.ObjectNamed(field.GetTypeName()) + msg := desc.(*generator.Descriptor) + for errStr, enabled := range enablers { + if enabled(msg.File(), msg.DescriptorProto) { + fmt.Fprintf(os.Stderr, "WARNING: found non-%v %v with embedded %v %v\n", names, ccTypeName, errStr, fieldname) + } + } + p.checkOverwrite(msg, enablers) + } + } +} + +func (p *plugin) checkRepeated(message *generator.Descriptor) { + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + for _, field := range message.Field { + if !gogoproto.IsEmbed(field) { + continue + } + if field.IsBytes() { + fieldname := generator.CamelCase(*field.Name) + fmt.Fprintf(os.Stderr, "ERROR: found embedded bytes field %s in message %s\n", fieldname, ccTypeName) + os.Exit(1) + } + if !field.IsRepeated() { + continue + } + fieldname := generator.CamelCase(*field.Name) + fmt.Fprintf(os.Stderr, "ERROR: found repeated embedded field %s in message %s\n", fieldname, ccTypeName) + os.Exit(1) + } +} + +func (p *plugin) GenerateImports(*generator.FileDescriptor) {} + +func init() { + generator.RegisterPlugin(NewPlugin()) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/enumstringer/enumstringer.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/enumstringer/enumstringer.go new file mode 100644 index 0000000000000000000000000000000000000000..81ebabde381982e98264c4acfdef3d7d8c9e97ca --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/enumstringer/enumstringer.go @@ -0,0 +1,102 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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. + +/* +The enumstringer (experimental) plugin generates a String method for each enum. + +It is enabled by the following extensions: + + - enum_stringer + - enum_stringer_all + +This package is subject to change. + +*/ +package enumstringer + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" +) + +type enumstringer struct { + *generator.Generator + generator.PluginImports + atleastOne bool + localName string +} + +func NewEnumStringer() *enumstringer { + return &enumstringer{} +} + +func (p *enumstringer) Name() string { + return "enumstringer" +} + +func (p *enumstringer) Init(g *generator.Generator) { + p.Generator = g +} + +func (p *enumstringer) Generate(file *generator.FileDescriptor) { + p.PluginImports = generator.NewPluginImports(p.Generator) + p.atleastOne = false + + p.localName = generator.FileName(file) + + strconvPkg := p.NewImport("strconv") + + for _, enum := range file.Enums() { + if !gogoproto.IsEnumStringer(file.FileDescriptorProto, enum.EnumDescriptorProto) { + continue + } + if gogoproto.IsGoEnumStringer(file.FileDescriptorProto, enum.EnumDescriptorProto) { + panic("old enum string method needs to be disabled, please use gogoproto.old_enum_stringer or gogoproto.old_enum_string_all and set it to false") + } + p.atleastOne = true + ccTypeName := generator.CamelCaseSlice(enum.TypeName()) + p.P("func (x ", ccTypeName, ") String() string {") + p.In() + p.P(`s, ok := `, ccTypeName, `_name[int32(x)]`) + p.P(`if ok {`) + p.In() + p.P(`return s`) + p.Out() + p.P(`}`) + p.P(`return `, strconvPkg.Use(), `.Itoa(int(x))`) + p.Out() + p.P(`}`) + } + + if !p.atleastOne { + return + } + +} + +func init() { + generator.RegisterPlugin(NewEnumStringer()) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/equal/equal.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/equal/equal.go new file mode 100644 index 0000000000000000000000000000000000000000..c9a1bf7191cf8e6cd6a755723a686e32dd4adf3d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/equal/equal.go @@ -0,0 +1,571 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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. + +/* +The equal plugin generates an Equal and a VerboseEqual method for each message. +These equal methods are quite obvious. +The only difference is that VerboseEqual returns a non nil error if it is not equal. +This error contains more detail on exactly which part of the message was not equal to the other message. +The idea is that this is useful for debugging. + +Equal is enabled using the following extensions: + + - equal + - equal_all + +While VerboseEqual is enable dusing the following extensions: + + - verbose_equal + - verbose_equal_all + +The equal plugin also generates a test given it is enabled using one of the following extensions: + + - testgen + - testgen_all + +Let us look at: + + github.com/gogo/protobuf/test/example/example.proto + +Btw all the output can be seen at: + + github.com/gogo/protobuf/test/example/* + +The following message: + + option (gogoproto.equal_all) = true; + option (gogoproto.verbose_equal_all) = true; + + message B { + optional A A = 1 [(gogoproto.nullable) = false, (gogoproto.embed) = true]; + repeated bytes G = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; + } + +given to the equal plugin, will generate the following code: + + func (this *B) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt2.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*B) + if !ok { + return fmt2.Errorf("that is not of type *B") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt2.Errorf("that is type *B but is nil && this != nil") + } else if this == nil { + return fmt2.Errorf("that is type *Bbut is not nil && this == nil") + } + if !this.A.Equal(&that1.A) { + return fmt2.Errorf("A this(%v) Not Equal that(%v)", this.A, that1.A) + } + if len(this.G) != len(that1.G) { + return fmt2.Errorf("G this(%v) Not Equal that(%v)", len(this.G), len(that1.G)) + } + for i := range this.G { + if !this.G[i].Equal(that1.G[i]) { + return fmt2.Errorf("G this[%v](%v) Not Equal that[%v](%v)", i, this.G[i], i, that1.G[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt2.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil + } + + func (this *B) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*B) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.A.Equal(&that1.A) { + return false + } + if len(this.G) != len(that1.G) { + return false + } + for i := range this.G { + if !this.G[i].Equal(that1.G[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true + } + +and the following test code: + + func TestBVerboseEqual(t *testing8.T) { + popr := math_rand8.New(math_rand8.NewSource(time8.Now().UnixNano())) + p := NewPopulatedB(popr, false) + data, err := github_com_gogo_protobuf_proto2.Marshal(p) + if err != nil { + panic(err) + } + msg := &B{} + if err := github_com_gogo_protobuf_proto2.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } + +*/ +package equal + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + descriptor "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity" +) + +type plugin struct { + *generator.Generator + generator.PluginImports + fmtPkg generator.Single + bytesPkg generator.Single +} + +func NewPlugin() *plugin { + return &plugin{} +} + +func (p *plugin) Name() string { + return "equal" +} + +func (p *plugin) Init(g *generator.Generator) { + p.Generator = g +} + +func (p *plugin) Generate(file *generator.FileDescriptor) { + p.PluginImports = generator.NewPluginImports(p.Generator) + p.fmtPkg = p.NewImport("fmt") + p.bytesPkg = p.NewImport("bytes") + + for _, msg := range file.Messages() { + if msg.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + if gogoproto.HasVerboseEqual(file.FileDescriptorProto, msg.DescriptorProto) { + p.generateMessage(file, msg, true) + } + if gogoproto.HasEqual(file.FileDescriptorProto, msg.DescriptorProto) { + p.generateMessage(file, msg, false) + } + } +} + +func (p *plugin) generateNullableField(fieldname string, verbose bool) { + p.P(`if this.`, fieldname, ` != nil && that1.`, fieldname, ` != nil {`) + p.In() + p.P(`if *this.`, fieldname, ` != *that1.`, fieldname, `{`) + p.In() + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("`, fieldname, ` this(%v) Not Equal that(%v)", *this.`, fieldname, `, *that1.`, fieldname, `)`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`}`) + p.Out() + p.P(`} else if this.`, fieldname, ` != nil {`) + p.In() + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("this.`, fieldname, ` == nil && that.`, fieldname, ` != nil")`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`} else if that1.`, fieldname, ` != nil {`) +} + +func (p *plugin) generateMsgNullAndTypeCheck(ccTypeName string, verbose bool) { + p.P(`if that == nil {`) + p.In() + p.P(`if this == nil {`) + p.In() + if verbose { + p.P(`return nil`) + } else { + p.P(`return true`) + } + p.Out() + p.P(`}`) + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("that == nil && this != nil")`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`}`) + p.P(``) + p.P(`that1, ok := that.(*`, ccTypeName, `)`) + p.P(`if !ok {`) + p.In() + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("that is not of type *`, ccTypeName, `")`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`}`) + p.P(`if that1 == nil {`) + p.In() + p.P(`if this == nil {`) + p.In() + if verbose { + p.P(`return nil`) + } else { + p.P(`return true`) + } + p.Out() + p.P(`}`) + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("that is type *`, ccTypeName, ` but is nil && this != nil")`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`} else if this == nil {`) + p.In() + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("that is type *`, ccTypeName, `but is not nil && this == nil")`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`}`) +} + +func (p *plugin) generateField(file *generator.FileDescriptor, message *generator.Descriptor, field *descriptor.FieldDescriptorProto, verbose bool) { + proto3 := gogoproto.IsProto3(file.FileDescriptorProto) + fieldname := p.GetOneOfFieldName(message, field) + repeated := field.IsRepeated() + ctype := gogoproto.IsCustomType(field) + nullable := gogoproto.IsNullable(field) + // oneof := field.OneofIndex != nil + if !repeated { + if ctype { + if nullable { + p.P(`if that1.`, fieldname, ` == nil {`) + p.In() + p.P(`if this.`, fieldname, ` != nil {`) + p.In() + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("this.`, fieldname, ` != nil && that1.`, fieldname, ` == nil")`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`}`) + p.Out() + p.P(`} else if !this.`, fieldname, `.Equal(*that1.`, fieldname, `) {`) + } else { + p.P(`if !this.`, fieldname, `.Equal(that1.`, fieldname, `) {`) + } + p.In() + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("`, fieldname, ` this(%v) Not Equal that(%v)", this.`, fieldname, `, that1.`, fieldname, `)`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`}`) + } else { + if field.IsMessage() || p.IsGroup(field) { + if nullable { + p.P(`if !this.`, fieldname, `.Equal(that1.`, fieldname, `) {`) + } else { + p.P(`if !this.`, fieldname, `.Equal(&that1.`, fieldname, `) {`) + } + } else if field.IsBytes() { + p.P(`if !`, p.bytesPkg.Use(), `.Equal(this.`, fieldname, `, that1.`, fieldname, `) {`) + } else if field.IsString() { + if nullable && !proto3 { + p.generateNullableField(fieldname, verbose) + } else { + p.P(`if this.`, fieldname, ` != that1.`, fieldname, `{`) + } + } else { + if nullable && !proto3 { + p.generateNullableField(fieldname, verbose) + } else { + p.P(`if this.`, fieldname, ` != that1.`, fieldname, `{`) + } + } + p.In() + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("`, fieldname, ` this(%v) Not Equal that(%v)", this.`, fieldname, `, that1.`, fieldname, `)`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`}`) + } + } else { + p.P(`if len(this.`, fieldname, `) != len(that1.`, fieldname, `) {`) + p.In() + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("`, fieldname, ` this(%v) Not Equal that(%v)", len(this.`, fieldname, `), len(that1.`, fieldname, `))`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`}`) + p.P(`for i := range this.`, fieldname, ` {`) + p.In() + if ctype { + p.P(`if !this.`, fieldname, `[i].Equal(that1.`, fieldname, `[i]) {`) + } else { + if generator.IsMap(file.FileDescriptorProto, field) { + mapMsg := generator.GetMap(file.FileDescriptorProto, field) + _, mapValue := mapMsg.GetMapFields() + if mapValue.IsMessage() || p.IsGroup(mapValue) { + p.P(`if !this.`, fieldname, `[i].Equal(that1.`, fieldname, `[i]) {`) + } else if mapValue.IsBytes() { + p.P(`if !`, p.bytesPkg.Use(), `.Equal(this.`, fieldname, `[i], that1.`, fieldname, `[i]) {`) + } else if mapValue.IsString() { + p.P(`if this.`, fieldname, `[i] != that1.`, fieldname, `[i] {`) + } else { + p.P(`if this.`, fieldname, `[i] != that1.`, fieldname, `[i] {`) + } + } else if field.IsMessage() || p.IsGroup(field) { + if nullable { + p.P(`if !this.`, fieldname, `[i].Equal(that1.`, fieldname, `[i]) {`) + } else { + p.P(`if !this.`, fieldname, `[i].Equal(&that1.`, fieldname, `[i]) {`) + } + } else if field.IsBytes() { + p.P(`if !`, p.bytesPkg.Use(), `.Equal(this.`, fieldname, `[i], that1.`, fieldname, `[i]) {`) + } else if field.IsString() { + p.P(`if this.`, fieldname, `[i] != that1.`, fieldname, `[i] {`) + } else { + p.P(`if this.`, fieldname, `[i] != that1.`, fieldname, `[i] {`) + } + } + p.In() + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("`, fieldname, ` this[%v](%v) Not Equal that[%v](%v)", i, this.`, fieldname, `[i], i, that1.`, fieldname, `[i])`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + } +} + +func (p *plugin) generateMessage(file *generator.FileDescriptor, message *generator.Descriptor, verbose bool) { + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + if verbose { + p.P(`func (this *`, ccTypeName, `) VerboseEqual(that interface{}) error {`) + } else { + p.P(`func (this *`, ccTypeName, `) Equal(that interface{}) bool {`) + } + p.In() + p.generateMsgNullAndTypeCheck(ccTypeName, verbose) + oneofs := make(map[string]struct{}) + + for _, field := range message.Field { + oneof := field.OneofIndex != nil + if oneof { + fieldname := p.GetFieldName(message, field) + if _, ok := oneofs[fieldname]; ok { + continue + } else { + oneofs[fieldname] = struct{}{} + } + p.P(`if that1.`, fieldname, ` == nil {`) + p.In() + p.P(`if this.`, fieldname, ` != nil {`) + p.In() + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("this.`, fieldname, ` != nil && that1.`, fieldname, ` == nil")`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`}`) + p.Out() + p.P(`} else if this.`, fieldname, ` == nil {`) + p.In() + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("this.`, fieldname, ` == nil && that1.`, fieldname, ` != nil")`) + } else { + p.P(`return false`) + } + p.Out() + if verbose { + p.P(`} else if err := this.`, fieldname, `.VerboseEqual(that1.`, fieldname, `); err != nil {`) + } else { + p.P(`} else if !this.`, fieldname, `.Equal(that1.`, fieldname, `) {`) + } + p.In() + if verbose { + p.P(`return err`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`}`) + } else { + p.generateField(file, message, field, verbose) + } + } + if message.DescriptorProto.HasExtension() { + fieldname := "XXX_extensions" + if gogoproto.HasExtensionsMap(file.FileDescriptorProto, message.DescriptorProto) { + p.P(`for k, v := range this.`, fieldname, ` {`) + p.In() + p.P(`if v2, ok := that1.`, fieldname, `[k]; ok {`) + p.In() + p.P(`if !v.Equal(&v2) {`) + p.In() + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("`, fieldname, ` this[%v](%v) Not Equal that[%v](%v)", k, this.`, fieldname, `[k], k, that1.`, fieldname, `[k])`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`}`) + p.Out() + p.P(`} else {`) + p.In() + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("`, fieldname, `[%v] Not In that", k)`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + + p.P(`for k, _ := range that1.`, fieldname, ` {`) + p.In() + p.P(`if _, ok := this.`, fieldname, `[k]; !ok {`) + p.In() + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("`, fieldname, `[%v] Not In this", k)`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + } else { + p.P(`if !`, p.bytesPkg.Use(), `.Equal(this.`, fieldname, `, that1.`, fieldname, `) {`) + p.In() + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("`, fieldname, ` this(%v) Not Equal that(%v)", this.`, fieldname, `, that1.`, fieldname, `)`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`}`) + } + } + if gogoproto.HasUnrecognized(file.FileDescriptorProto, message.DescriptorProto) { + fieldname := "XXX_unrecognized" + p.P(`if !`, p.bytesPkg.Use(), `.Equal(this.`, fieldname, `, that1.`, fieldname, `) {`) + p.In() + if verbose { + p.P(`return `, p.fmtPkg.Use(), `.Errorf("`, fieldname, ` this(%v) Not Equal that(%v)", this.`, fieldname, `, that1.`, fieldname, `)`) + } else { + p.P(`return false`) + } + p.Out() + p.P(`}`) + } + if verbose { + p.P(`return nil`) + } else { + p.P(`return true`) + } + p.Out() + p.P(`}`) + + //Generate Equal methods for oneof fields + m := proto.Clone(message.DescriptorProto).(*descriptor.DescriptorProto) + for _, field := range m.Field { + oneof := field.OneofIndex != nil + if !oneof { + continue + } + ccTypeName := p.OneOfTypeName(message, field) + if verbose { + p.P(`func (this *`, ccTypeName, `) VerboseEqual(that interface{}) error {`) + } else { + p.P(`func (this *`, ccTypeName, `) Equal(that interface{}) bool {`) + } + p.In() + + p.generateMsgNullAndTypeCheck(ccTypeName, verbose) + vanity.TurnOffNullableForNativeTypesWithoutDefaultsOnly(field) + p.generateField(file, message, field, verbose) + + if verbose { + p.P(`return nil`) + } else { + p.P(`return true`) + } + p.Out() + p.P(`}`) + } +} + +func init() { + generator.RegisterPlugin(NewPlugin()) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/equal/equaltest.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/equal/equaltest.go new file mode 100644 index 0000000000000000000000000000000000000000..525bec60f86dc69d4796ef543b86b6d739605e65 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/equal/equaltest.go @@ -0,0 +1,94 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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 equal + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/testgen" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" +) + +type test struct { + *generator.Generator +} + +func NewTest(g *generator.Generator) testgen.TestPlugin { + return &test{g} +} + +func (p *test) Generate(imports generator.PluginImports, file *generator.FileDescriptor) bool { + used := false + randPkg := imports.NewImport("math/rand") + timePkg := imports.NewImport("time") + testingPkg := imports.NewImport("testing") + protoPkg := imports.NewImport("github.com/gogo/protobuf/proto") + if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) { + protoPkg = imports.NewImport("github.com/golang/protobuf/proto") + } + for _, message := range file.Messages() { + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + if !gogoproto.HasVerboseEqual(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + + if gogoproto.HasTestGen(file.FileDescriptorProto, message.DescriptorProto) { + used = true + p.P(`func Test`, ccTypeName, `VerboseEqual(t *`, testingPkg.Use(), `.T) {`) + p.In() + p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(`, timePkg.Use(), `.Now().UnixNano()))`) + p.P(`p := NewPopulated`, ccTypeName, `(popr, false)`) + p.P(`data, err := `, protoPkg.Use(), `.Marshal(p)`) + p.P(`if err != nil {`) + p.In() + p.P(`panic(err)`) + p.Out() + p.P(`}`) + p.P(`msg := &`, ccTypeName, `{}`) + p.P(`if err := `, protoPkg.Use(), `.Unmarshal(data, msg); err != nil {`) + p.In() + p.P(`panic(err)`) + p.Out() + p.P(`}`) + p.P(`if err := p.VerboseEqual(msg); err != nil {`) + p.In() + p.P(`t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err)`) + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + } + + } + return used +} + +func init() { + testgen.RegisterTestPlugin(NewTest) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/face/face.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/face/face.go new file mode 100644 index 0000000000000000000000000000000000000000..5af9cb44f4851b568e15dc01eebc0d525bac7ceb --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/face/face.go @@ -0,0 +1,244 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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. + +/* +The face plugin generates a function will be generated which can convert a structure which satisfies an interface (face) to the specified structure. +This interface contains getters for each of the fields in the struct. +The specified struct is also generated with the getters. +This means that getters should be turned off so as not to conflict with face getters. +This allows it to satisfy its own face. + +It is enabled by the following extensions: + + - face + - face_all + +Turn off getters by using the following extensions: + + - getters + - getters_all + +The face plugin also generates a test given it is enabled using one of the following extensions: + + - testgen + - testgen_all + +Let us look at: + + github.com/gogo/protobuf/test/example/example.proto + +Btw all the output can be seen at: + + github.com/gogo/protobuf/test/example/* + +The following message: + + message A { + option (gogoproto.face) = true; + option (gogoproto.goproto_getters) = false; + optional string Description = 1 [(gogoproto.nullable) = false]; + optional int64 Number = 2 [(gogoproto.nullable) = false]; + optional bytes Id = 3 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uuid", (gogoproto.nullable) = false]; + } + +given to the face plugin, will generate the following code: + + type AFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetDescription() string + GetNumber() int64 + GetId() github_com_gogo_protobuf_test_custom.Uuid + } + + func (this *A) Proto() github_com_gogo_protobuf_proto.Message { + return this + } + + func (this *A) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAFromFace(this) + } + + func (this *A) GetDescription() string { + return this.Description + } + + func (this *A) GetNumber() int64 { + return this.Number + } + + func (this *A) GetId() github_com_gogo_protobuf_test_custom.Uuid { + return this.Id + } + + func NewAFromFace(that AFace) *A { + this := &A{} + this.Description = that.GetDescription() + this.Number = that.GetNumber() + this.Id = that.GetId() + return this + } + +and the following test code: + + func TestAFace(t *testing7.T) { + popr := math_rand7.New(math_rand7.NewSource(time7.Now().UnixNano())) + p := NewPopulatedA(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } + } + +The struct A, representing the message, will also be generated just like always. +As you can see A satisfies its own Face, AFace. + +Creating another struct which satisfies AFace is very easy. +Simply create all these methods specified in AFace. +Implementing The Proto method is done with the helper function NewAFromFace: + + func (this *MyStruct) Proto() proto.Message { + return NewAFromFace(this) + } + +just the like TestProto method which is used to test the NewAFromFace function. + +*/ +package face + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + descriptor "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" + "strings" +) + +type plugin struct { + *generator.Generator + generator.PluginImports +} + +func NewPlugin() *plugin { + return &plugin{} +} + +func (p *plugin) Name() string { + return "face" +} + +func (p *plugin) Init(g *generator.Generator) { + p.Generator = g +} + +func (p *plugin) GetMapGoType(file *descriptor.FileDescriptorProto, field *descriptor.FieldDescriptorProto) string { + mapMsg := generator.GetMap(file, field) + keyField, valueField := mapMsg.GetMapFields() + keygoTyp, _ := p.GoType(nil, keyField) + keygoTyp = strings.Replace(keygoTyp, "*", "", 1) + valuegoTyp, _ := p.GoType(nil, valueField) + if !valueField.IsMessage() { + valuegoTyp = strings.Replace(valuegoTyp, "*", "", 1) + } + goTyp := "map[" + keygoTyp + "]" + valuegoTyp + return goTyp +} + +func (p *plugin) Generate(file *generator.FileDescriptor) { + p.PluginImports = generator.NewPluginImports(p.Generator) + protoPkg := p.NewImport("github.com/gogo/protobuf/proto") + if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) { + protoPkg = p.NewImport("github.com/golang/protobuf/proto") + } + for _, message := range file.Messages() { + if !gogoproto.IsFace(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + if message.DescriptorProto.HasExtension() { + panic("face does not support message with extensions") + } + if gogoproto.HasGoGetters(file.FileDescriptorProto, message.DescriptorProto) { + panic("face requires getters to be disabled please use gogoproto.getters or gogoproto.getters_all and set it to false") + } + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + p.P(`type `, ccTypeName, `Face interface{`) + p.In() + p.P(`Proto() `, protoPkg.Use(), `.Message`) + for _, field := range message.Field { + fieldname := p.GetFieldName(message, field) + goTyp, _ := p.GoType(message, field) + if generator.IsMap(file.FileDescriptorProto, field) { + goTyp = p.GetMapGoType(file.FileDescriptorProto, field) + } + p.P(`Get`, fieldname, `() `, goTyp) + } + p.Out() + p.P(`}`) + p.P(``) + p.P(`func (this *`, ccTypeName, `) Proto() `, protoPkg.Use(), `.Message {`) + p.In() + p.P(`return this`) + p.Out() + p.P(`}`) + p.P(``) + p.P(`func (this *`, ccTypeName, `) TestProto() `, protoPkg.Use(), `.Message {`) + p.In() + p.P(`return New`, ccTypeName, `FromFace(this)`) + p.Out() + p.P(`}`) + p.P(``) + for _, field := range message.Field { + fieldname := p.GetFieldName(message, field) + goTyp, _ := p.GoType(message, field) + if generator.IsMap(file.FileDescriptorProto, field) { + goTyp = p.GetMapGoType(file.FileDescriptorProto, field) + } + p.P(`func (this *`, ccTypeName, `) Get`, fieldname, `() `, goTyp, `{`) + p.In() + p.P(` return this.`, fieldname) + p.Out() + p.P(`}`) + p.P(``) + } + p.P(``) + p.P(`func New`, ccTypeName, `FromFace(that `, ccTypeName, `Face) *`, ccTypeName, ` {`) + p.In() + p.P(`this := &`, ccTypeName, `{}`) + for _, field := range message.Field { + fieldname := p.GetFieldName(message, field) + p.P(`this.`, fieldname, ` = that.Get`, fieldname, `()`) + } + p.P(`return this`) + p.Out() + p.P(`}`) + p.P(``) + } +} + +func init() { + generator.RegisterPlugin(NewPlugin()) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/face/facetest.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/face/facetest.go new file mode 100644 index 0000000000000000000000000000000000000000..f0ee75243a21692860832e47d5978b3a66e996fe --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/face/facetest.go @@ -0,0 +1,80 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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 face + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/testgen" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" +) + +type test struct { + *generator.Generator +} + +func NewTest(g *generator.Generator) testgen.TestPlugin { + return &test{g} +} + +func (p *test) Generate(imports generator.PluginImports, file *generator.FileDescriptor) bool { + used := false + randPkg := imports.NewImport("math/rand") + timePkg := imports.NewImport("time") + testingPkg := imports.NewImport("testing") + for _, message := range file.Messages() { + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + if !gogoproto.IsFace(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + + if gogoproto.HasTestGen(file.FileDescriptorProto, message.DescriptorProto) { + used = true + + p.P(`func Test`, ccTypeName, `Face(t *`, testingPkg.Use(), `.T) {`) + p.In() + p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(`, timePkg.Use(), `.Now().UnixNano()))`) + p.P(`p := NewPopulated`, ccTypeName, `(popr, true)`) + p.P(`msg := p.TestProto()`) + p.P(`if !p.Equal(msg) {`) + p.In() + p.P(`t.Fatalf("%#v !Face Equal %#v", msg, p)`) + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + } + + } + return used +} + +func init() { + testgen.RegisterTestPlugin(NewTest) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/gostring/gostring.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/gostring/gostring.go new file mode 100644 index 0000000000000000000000000000000000000000..a891d11ea5074950b8cf0b0e5c7258aa2eff65c4 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/gostring/gostring.go @@ -0,0 +1,356 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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. + +/* +The gostring plugin generates a GoString method for each message. +The GoString method is called whenever you use a fmt.Printf as such: + + fmt.Printf("%#v", mymessage) + +or whenever you actually call GoString() +The output produced by the GoString method can be copied from the output into code and used to set a variable. +It is totally valid Go Code and is populated exactly as the struct that was printed out. + +It is enabled by the following extensions: + + - gostring + - gostring_all + +The gostring plugin also generates a test given it is enabled using one of the following extensions: + + - testgen + - testgen_all + +Let us look at: + + github.com/gogo/protobuf/test/example/example.proto + +Btw all the output can be seen at: + + github.com/gogo/protobuf/test/example/* + +The following message: + + option (gogoproto.gostring_all) = true; + + message A { + optional string Description = 1 [(gogoproto.nullable) = false]; + optional int64 Number = 2 [(gogoproto.nullable) = false]; + optional bytes Id = 3 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uuid", (gogoproto.nullable) = false]; + } + +given to the gostring plugin, will generate the following code: + + func (this *A) GoString() string { + if this == nil { + return "nil" + } + s := strings1.Join([]string{`&test.A{` + `Description:` + fmt1.Sprintf("%#v", this.Description), `Number:` + fmt1.Sprintf("%#v", this.Number), `Id:` + fmt1.Sprintf("%#v", this.Id), `XXX_unrecognized:` + fmt1.Sprintf("%#v", this.XXX_unrecognized) + `}`}, ", ") + return s + } + +and the following test code: + + func TestAGoString(t *testing6.T) { + popr := math_rand6.New(math_rand6.NewSource(time6.Now().UnixNano())) + p := NewPopulatedA(popr, false) + s1 := p.GoString() + s2 := fmt2.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } + } + +Typically fmt.Printf("%#v") will stop to print when it reaches a pointer and +not print their values, while the generated GoString method will always print all values, recursively. + +*/ +package gostring + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" + "strconv" + "strings" +) + +type gostring struct { + *generator.Generator + generator.PluginImports + atleastOne bool + localName string +} + +func NewGoString() *gostring { + return &gostring{} +} + +func (p *gostring) Name() string { + return "gostring" +} + +func (p *gostring) Init(g *generator.Generator) { + p.Generator = g +} + +func (p *gostring) Generate(file *generator.FileDescriptor) { + proto3 := gogoproto.IsProto3(file.FileDescriptorProto) + p.PluginImports = generator.NewPluginImports(p.Generator) + p.atleastOne = false + + p.localName = generator.FileName(file) + + fmtPkg := p.NewImport("fmt") + stringsPkg := p.NewImport("strings") + protoPkg := p.NewImport("github.com/gogo/protobuf/proto") + if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) { + protoPkg = p.NewImport("github.com/golang/protobuf/proto") + } + sortPkg := p.NewImport("sort") + strconvPkg := p.NewImport("strconv") + reflectPkg := p.NewImport("reflect") + sortKeysPkg := p.NewImport("github.com/gogo/protobuf/sortkeys") + + for _, message := range file.Messages() { + if !gogoproto.HasGoString(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + p.atleastOne = true + packageName := file.PackageName() + + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + p.P(`func (this *`, ccTypeName, `) GoString() string {`) + p.In() + p.P(`if this == nil {`) + p.In() + p.P(`return "nil"`) + p.Out() + p.P(`}`) + + p.P(`s := make([]string, 0, `, strconv.Itoa(len(message.Field)+4), `)`) + p.P(`s = append(s, "&`, packageName, ".", ccTypeName, `{")`) + + oneofs := make(map[string]struct{}) + for _, field := range message.Field { + nullable := gogoproto.IsNullable(field) + repeated := field.IsRepeated() + fieldname := p.GetFieldName(message, field) + oneof := field.OneofIndex != nil + if oneof { + if _, ok := oneofs[fieldname]; ok { + continue + } else { + oneofs[fieldname] = struct{}{} + } + p.P(`if this.`, fieldname, ` != nil {`) + p.In() + p.P(`s = append(s, "`, fieldname, `: " + `, fmtPkg.Use(), `.Sprintf("%#v", this.`, fieldname, `) + ",\n")`) + p.Out() + p.P(`}`) + } else if generator.IsMap(file.FileDescriptorProto, field) { + mapMsg := generator.GetMap(file.FileDescriptorProto, field) + keyField, valueField := mapMsg.GetMapFields() + keysName := `keysFor` + fieldname + keygoTyp, _ := p.GoType(nil, keyField) + keygoTyp = strings.Replace(keygoTyp, "*", "", 1) + keyCapTyp := generator.CamelCase(keygoTyp) + valuegoTyp, _ := p.GoType(nil, valueField) + if !valueField.IsMessage() { + valuegoTyp = strings.Replace(valuegoTyp, "*", "", 1) + } + p.P(keysName, ` := make([]`, keygoTyp, `, 0, len(this.`, fieldname, `))`) + p.P(`for k, _ := range this.`, fieldname, ` {`) + p.In() + p.P(keysName, ` = append(`, keysName, `, k)`) + p.Out() + p.P(`}`) + p.P(sortKeysPkg.Use(), `.`, keyCapTyp, `s(`, keysName, `)`) + mapName := `mapStringFor` + fieldname + p.P(mapName, ` := "map[`, keygoTyp, `]`, valuegoTyp, `{"`) + p.P(`for _, k := range `, keysName, ` {`) + p.In() + p.P(mapName, ` += fmt.Sprintf("%#v: %#v,", k, this.`, fieldname, `[k])`) + p.Out() + p.P(`}`) + p.P(mapName, ` += "}"`) + p.P(`if this.`, fieldname, ` != nil {`) + p.In() + p.P(`s = append(s, "`, fieldname, `: " + `, mapName, `+ ",\n")`) + p.Out() + p.P(`}`) + } else if field.IsMessage() || p.IsGroup(field) { + if nullable || repeated { + p.P(`if this.`, fieldname, ` != nil {`) + p.In() + } + if nullable { + p.P(`s = append(s, "`, fieldname, `: " + `, fmtPkg.Use(), `.Sprintf("%#v", this.`, fieldname, `) + ",\n")`) + } else if repeated { + p.P(`s = append(s, "`, fieldname, `: " + `, stringsPkg.Use(), `.Replace(`, fmtPkg.Use(), `.Sprintf("%#v", this.`, fieldname, `)`, ",`&`,``,1)", ` + ",\n")`) + } else { + p.P(`s = append(s, "`, fieldname, `: " + `, stringsPkg.Use(), `.Replace(this.`, fieldname, `.GoString()`, ",`&`,``,1)", ` + ",\n")`) + } + if nullable || repeated { + p.Out() + p.P(`}`) + } + } else { + if !proto3 && (nullable || repeated) { + p.P(`if this.`, fieldname, ` != nil {`) + p.In() + } + if field.IsEnum() { + if nullable && !repeated && !proto3 { + goTyp, _ := p.GoType(message, field) + p.P(`s = append(s, "`, fieldname, `: " + valueToGoString`, p.localName, `(this.`, fieldname, `,"`, packageName, ".", generator.GoTypeToName(goTyp), `"`, `) + ",\n")`) + } else { + p.P(`s = append(s, "`, fieldname, `: " + `, fmtPkg.Use(), `.Sprintf("%#v", this.`, fieldname, `) + ",\n")`) + } + } else { + if nullable && !repeated && !proto3 { + goTyp, _ := p.GoType(message, field) + p.P(`s = append(s, "`, fieldname, `: " + valueToGoString`, p.localName, `(this.`, fieldname, `,"`, generator.GoTypeToName(goTyp), `"`, `) + ",\n")`) + } else { + p.P(`s = append(s, "`, fieldname, `: " + `, fmtPkg.Use(), `.Sprintf("%#v", this.`, fieldname, `) + ",\n")`) + } + } + if !proto3 && (nullable || repeated) { + p.Out() + p.P(`}`) + } + } + } + if message.DescriptorProto.HasExtension() { + p.P(`if this.XXX_extensions != nil {`) + p.In() + if gogoproto.HasExtensionsMap(file.FileDescriptorProto, message.DescriptorProto) { + p.P(`s = append(s, "XXX_extensions: " + extensionToGoString`, p.localName, `(this.XXX_extensions) + ",\n")`) + } else { + p.P(`s = append(s, "XXX_extensions: " + `, fmtPkg.Use(), `.Sprintf("%#v", this.XXX_extensions) + ",\n")`) + } + p.Out() + p.P(`}`) + } + if gogoproto.HasUnrecognized(file.FileDescriptorProto, message.DescriptorProto) { + p.P(`if this.XXX_unrecognized != nil {`) + p.In() + p.P(`s = append(s, "XXX_unrecognized:" + `, fmtPkg.Use(), `.Sprintf("%#v", this.XXX_unrecognized) + ",\n")`) + p.Out() + p.P(`}`) + } + + p.P(`s = append(s, "}")`) + //outStr += strings.Join([]string{" + `}`", `}`, `,", "`, ")"}, "") + p.P(`return `, stringsPkg.Use(), `.Join(s, "")`) + p.Out() + p.P(`}`) + + //Generate GoString methods for oneof fields + for _, field := range message.Field { + oneof := field.OneofIndex != nil + if !oneof { + continue + } + ccTypeName := p.OneOfTypeName(message, field) + p.P(`func (this *`, ccTypeName, `) GoString() string {`) + p.In() + p.P(`if this == nil {`) + p.In() + p.P(`return "nil"`) + p.Out() + p.P(`}`) + outFlds := []string{} + fieldname := p.GetOneOfFieldName(message, field) + if field.IsMessage() || p.IsGroup(field) { + tmp := strings.Join([]string{"`", fieldname, ":` + "}, "") + tmp += strings.Join([]string{fmtPkg.Use(), `.Sprintf("%#v", this.`, fieldname, `)`}, "") + outFlds = append(outFlds, tmp) + } else { + tmp := strings.Join([]string{"`", fieldname, ":` + "}, "") + tmp += strings.Join([]string{fmtPkg.Use(), `.Sprintf("%#v", this.`, fieldname, ")"}, "") + outFlds = append(outFlds, tmp) + } + outStr := strings.Join([]string{"s := ", stringsPkg.Use(), ".Join([]string{`&", packageName, ".", ccTypeName, "{` + \n"}, "") + outStr += strings.Join(outFlds, ",\n") + outStr += strings.Join([]string{" + `}`", `}`, `,", "`, ")"}, "") + p.P(outStr) + p.P(`return s`) + p.Out() + p.P(`}`) + } + } + + if !p.atleastOne { + return + } + + p.P(`func valueToGoString`, p.localName, `(v interface{}, typ string) string {`) + p.In() + p.P(`rv := `, reflectPkg.Use(), `.ValueOf(v)`) + p.P(`if rv.IsNil() {`) + p.In() + p.P(`return "nil"`) + p.Out() + p.P(`}`) + p.P(`pv := `, reflectPkg.Use(), `.Indirect(rv).Interface()`) + p.P(`return `, fmtPkg.Use(), `.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)`) + p.Out() + p.P(`}`) + + p.P(`func extensionToGoString`, p.localName, `(e map[int32]`, protoPkg.Use(), `.Extension) string {`) + p.In() + p.P(`if e == nil { return "nil" }`) + p.P(`s := "map[int32]proto.Extension{"`) + p.P(`keys := make([]int, 0, len(e))`) + p.P(`for k := range e {`) + p.In() + p.P(`keys = append(keys, int(k))`) + p.Out() + p.P(`}`) + p.P(sortPkg.Use(), `.Ints(keys)`) + p.P(`ss := []string{}`) + p.P(`for _, k := range keys {`) + p.In() + p.P(`ss = append(ss, `, strconvPkg.Use(), `.Itoa(k) + ": " + e[int32(k)].GoString())`) + p.Out() + p.P(`}`) + p.P(`s+=`, stringsPkg.Use(), `.Join(ss, ",") + "}"`) + p.P(`return s`) + p.Out() + p.P(`}`) + +} + +func init() { + generator.RegisterPlugin(NewGoString()) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/gostring/gostringtest.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/gostring/gostringtest.go new file mode 100644 index 0000000000000000000000000000000000000000..3f5b6aee5967e8bf3160e95d758b4bcf977b9e30 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/gostring/gostringtest.go @@ -0,0 +1,88 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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 gostring + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/testgen" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" +) + +type test struct { + *generator.Generator +} + +func NewTest(g *generator.Generator) testgen.TestPlugin { + return &test{g} +} + +func (p *test) Generate(imports generator.PluginImports, file *generator.FileDescriptor) bool { + used := false + randPkg := imports.NewImport("math/rand") + timePkg := imports.NewImport("time") + testingPkg := imports.NewImport("testing") + fmtPkg := imports.NewImport("fmt") + parserPkg := imports.NewImport("go/parser") + for _, message := range file.Messages() { + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + if !gogoproto.HasGoString(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + + if gogoproto.HasTestGen(file.FileDescriptorProto, message.DescriptorProto) { + used = true + p.P(`func Test`, ccTypeName, `GoString(t *`, testingPkg.Use(), `.T) {`) + p.In() + p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(`, timePkg.Use(), `.Now().UnixNano()))`) + p.P(`p := NewPopulated`, ccTypeName, `(popr, false)`) + p.P(`s1 := p.GoString()`) + p.P(`s2 := `, fmtPkg.Use(), `.Sprintf("%#v", p)`) + p.P(`if s1 != s2 {`) + p.In() + p.P(`t.Fatalf("GoString want %v got %v", s1, s2)`) + p.Out() + p.P(`}`) + p.P(`_, err := `, parserPkg.Use(), `.ParseExpr(s1)`) + p.P(`if err != nil {`) + p.In() + p.P(`panic(err)`) + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + } + + } + return used +} + +func init() { + testgen.RegisterTestPlugin(NewTest) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/grpc/grpc.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/grpc/grpc.go new file mode 100644 index 0000000000000000000000000000000000000000..50bfc0f80568d6ac9862eb1bd26727db89e9b139 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/grpc/grpc.go @@ -0,0 +1,439 @@ +// 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 grpc outputs gRPC service descriptions in Go code. +// It runs as a plugin for the Go protocol buffer compiler plugin. +// It is linked in to protoc-gen-go. +package grpc + +import ( + "fmt" + "path" + "strconv" + "strings" + + pb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" +) + +// Paths for packages used by code generated in this file, +// relative to the import_prefix of the generator.Generator. +const ( + contextPkgPath = "golang.org/x/net/context" + grpcPkgPath = "google.golang.org/grpc" +) + +func init() { + generator.RegisterPlugin(new(grpc)) +} + +// grpc is an implementation of the Go protocol buffer compiler's +// plugin architecture. It generates bindings for gRPC support. +type grpc struct { + gen *generator.Generator +} + +// Name returns the name of this plugin, "grpc". +func (g *grpc) Name() string { + return "grpc" +} + +// The names for packages imported in the generated code. +// They may vary from the final path component of the import path +// if the name is used by other packages. +var ( + contextPkg string + grpcPkg string +) + +// Init initializes the plugin. +func (g *grpc) Init(gen *generator.Generator) { + g.gen = gen + contextPkg = generator.RegisterUniquePackageName("context", nil) + grpcPkg = generator.RegisterUniquePackageName("grpc", nil) +} + +// Given a type name defined in a .proto, return its object. +// Also record that we're using it, to guarantee the associated import. +func (g *grpc) objectNamed(name string) generator.Object { + g.gen.RecordTypeUse(name) + return g.gen.ObjectNamed(name) +} + +// Given a type name defined in a .proto, return its name as we will print it. +func (g *grpc) typeName(str string) string { + return g.gen.TypeName(g.objectNamed(str)) +} + +// P forwards to g.gen.P. +func (g *grpc) P(args ...interface{}) { g.gen.P(args...) } + +// Generate generates code for the services in the given file. +func (g *grpc) Generate(file *generator.FileDescriptor) { + if len(file.FileDescriptorProto.Service) == 0 { + return + } + g.P("// Reference imports to suppress errors if they are not otherwise used.") + g.P("var _ ", contextPkg, ".Context") + g.P("var _ ", grpcPkg, ".ClientConn") + g.P() + for i, service := range file.FileDescriptorProto.Service { + g.generateService(file, service, i) + } +} + +// GenerateImports generates the import declaration for this file. +func (g *grpc) GenerateImports(file *generator.FileDescriptor) { + if len(file.FileDescriptorProto.Service) == 0 { + return + } + g.P("import (") + g.P(contextPkg, " ", strconv.Quote(path.Join(g.gen.ImportPrefix, contextPkgPath))) + g.P(grpcPkg, " ", strconv.Quote(path.Join(g.gen.ImportPrefix, grpcPkgPath))) + g.P(")") + g.P() +} + +// reservedClientName records whether a client name is reserved on the client side. +var reservedClientName = map[string]bool{ +// TODO: do we need any in gRPC? +} + +func unexport(s string) string { return strings.ToLower(s[:1]) + s[1:] } + +// generateService generates all the code for the named service. +func (g *grpc) generateService(file *generator.FileDescriptor, service *pb.ServiceDescriptorProto, index int) { + path := fmt.Sprintf("6,%d", index) // 6 means service. + + origServName := service.GetName() + fullServName := file.GetPackage() + "." + origServName + servName := generator.CamelCase(origServName) + + g.P() + g.P("// Client API for ", servName, " service") + g.P() + + // Client interface. + g.P("type ", servName, "Client interface {") + for i, method := range service.Method { + g.gen.PrintComments(fmt.Sprintf("%s,2,%d", path, i)) // 2 means method in a service. + g.P(g.generateClientSignature(servName, method)) + } + g.P("}") + g.P() + + // Client structure. + g.P("type ", unexport(servName), "Client struct {") + g.P("cc *", grpcPkg, ".ClientConn") + g.P("}") + g.P() + + // NewClient factory. + g.P("func New", servName, "Client (cc *", grpcPkg, ".ClientConn) ", servName, "Client {") + g.P("return &", unexport(servName), "Client{cc}") + g.P("}") + g.P() + + var methodIndex, streamIndex int + serviceDescVar := "_" + servName + "_serviceDesc" + // Client method implementations. + for _, method := range service.Method { + var descExpr string + if !method.GetServerStreaming() && !method.GetClientStreaming() { + // Unary RPC method + descExpr = fmt.Sprintf("&%s.Methods[%d]", serviceDescVar, methodIndex) + methodIndex++ + } else { + // Streaming RPC method + descExpr = fmt.Sprintf("&%s.Streams[%d]", serviceDescVar, streamIndex) + streamIndex++ + } + g.generateClientMethod(servName, fullServName, serviceDescVar, method, descExpr) + } + + g.P("// Server API for ", servName, " service") + g.P() + + // Server interface. + serverType := servName + "Server" + g.P("type ", serverType, " interface {") + for i, method := range service.Method { + g.gen.PrintComments(fmt.Sprintf("%s,2,%d", path, i)) // 2 means method in a service. + g.P(g.generateServerSignature(servName, method)) + } + g.P("}") + g.P() + + // Server registration. + g.P("func Register", servName, "Server(s *", grpcPkg, ".Server, srv ", serverType, ") {") + g.P("s.RegisterService(&", serviceDescVar, `, srv)`) + g.P("}") + g.P() + + // Server handler implementations. + var handlerNames []string + for _, method := range service.Method { + hname := g.generateServerMethod(servName, method) + handlerNames = append(handlerNames, hname) + } + + // Service descriptor. + g.P("var ", serviceDescVar, " = ", grpcPkg, ".ServiceDesc {") + g.P("ServiceName: ", strconv.Quote(fullServName), ",") + g.P("HandlerType: (*", serverType, ")(nil),") + g.P("Methods: []", grpcPkg, ".MethodDesc{") + for i, method := range service.Method { + if method.GetServerStreaming() || method.GetClientStreaming() { + continue + } + g.P("{") + g.P("MethodName: ", strconv.Quote(method.GetName()), ",") + g.P("Handler: ", handlerNames[i], ",") + g.P("},") + } + g.P("},") + g.P("Streams: []", grpcPkg, ".StreamDesc{") + for i, method := range service.Method { + if !method.GetServerStreaming() && !method.GetClientStreaming() { + continue + } + g.P("{") + g.P("StreamName: ", strconv.Quote(method.GetName()), ",") + g.P("Handler: ", handlerNames[i], ",") + if method.GetServerStreaming() { + g.P("ServerStreams: true,") + } + if method.GetClientStreaming() { + g.P("ClientStreams: true,") + } + g.P("},") + } + g.P("},") + g.P("}") + g.P() +} + +// generateClientSignature returns the client-side signature for a method. +func (g *grpc) generateClientSignature(servName string, method *pb.MethodDescriptorProto) string { + origMethName := method.GetName() + methName := generator.CamelCase(origMethName) + if reservedClientName[methName] { + methName += "_" + } + reqArg := ", in *" + g.typeName(method.GetInputType()) + if method.GetClientStreaming() { + reqArg = "" + } + respName := "*" + g.typeName(method.GetOutputType()) + if method.GetServerStreaming() || method.GetClientStreaming() { + respName = servName + "_" + generator.CamelCase(origMethName) + "Client" + } + return fmt.Sprintf("%s(ctx %s.Context%s, opts ...%s.CallOption) (%s, error)", methName, contextPkg, reqArg, grpcPkg, respName) +} + +func (g *grpc) generateClientMethod(servName, fullServName, serviceDescVar string, method *pb.MethodDescriptorProto, descExpr string) { + sname := fmt.Sprintf("/%s/%s", fullServName, method.GetName()) + methName := generator.CamelCase(method.GetName()) + inType := g.typeName(method.GetInputType()) + outType := g.typeName(method.GetOutputType()) + + g.P("func (c *", unexport(servName), "Client) ", g.generateClientSignature(servName, method), "{") + if !method.GetServerStreaming() && !method.GetClientStreaming() { + g.P("out := new(", outType, ")") + // TODO: Pass descExpr to Invoke. + g.P("err := ", grpcPkg, `.Invoke(ctx, "`, sname, `", in, out, c.cc, opts...)`) + g.P("if err != nil { return nil, err }") + g.P("return out, nil") + g.P("}") + g.P() + return + } + streamType := unexport(servName) + methName + "Client" + g.P("stream, err := ", grpcPkg, ".NewClientStream(ctx, ", descExpr, `, c.cc, "`, sname, `", opts...)`) + g.P("if err != nil { return nil, err }") + g.P("x := &", streamType, "{stream}") + if !method.GetClientStreaming() { + g.P("if err := x.ClientStream.SendMsg(in); err != nil { return nil, err }") + g.P("if err := x.ClientStream.CloseSend(); err != nil { return nil, err }") + } + g.P("return x, nil") + g.P("}") + g.P() + + genSend := method.GetClientStreaming() + genRecv := method.GetServerStreaming() + genCloseAndRecv := !method.GetServerStreaming() + + // Stream auxiliary types and methods. + g.P("type ", servName, "_", methName, "Client interface {") + if genSend { + g.P("Send(*", inType, ") error") + } + if genRecv { + g.P("Recv() (*", outType, ", error)") + } + if genCloseAndRecv { + g.P("CloseAndRecv() (*", outType, ", error)") + } + g.P(grpcPkg, ".ClientStream") + g.P("}") + g.P() + + g.P("type ", streamType, " struct {") + g.P(grpcPkg, ".ClientStream") + g.P("}") + g.P() + + if genSend { + g.P("func (x *", streamType, ") Send(m *", inType, ") error {") + g.P("return x.ClientStream.SendMsg(m)") + g.P("}") + g.P() + } + if genRecv { + g.P("func (x *", streamType, ") Recv() (*", outType, ", error) {") + g.P("m := new(", outType, ")") + g.P("if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err }") + g.P("return m, nil") + g.P("}") + g.P() + } + if genCloseAndRecv { + g.P("func (x *", streamType, ") CloseAndRecv() (*", outType, ", error) {") + g.P("if err := x.ClientStream.CloseSend(); err != nil { return nil, err }") + g.P("m := new(", outType, ")") + g.P("if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err }") + g.P("return m, nil") + g.P("}") + g.P() + } +} + +// generateServerSignature returns the server-side signature for a method. +func (g *grpc) generateServerSignature(servName string, method *pb.MethodDescriptorProto) string { + origMethName := method.GetName() + methName := generator.CamelCase(origMethName) + if reservedClientName[methName] { + methName += "_" + } + + var reqArgs []string + ret := "error" + if !method.GetServerStreaming() && !method.GetClientStreaming() { + reqArgs = append(reqArgs, contextPkg+".Context") + ret = "(*" + g.typeName(method.GetOutputType()) + ", error)" + } + if !method.GetClientStreaming() { + reqArgs = append(reqArgs, "*"+g.typeName(method.GetInputType())) + } + if method.GetServerStreaming() || method.GetClientStreaming() { + reqArgs = append(reqArgs, servName+"_"+generator.CamelCase(origMethName)+"Server") + } + + return methName + "(" + strings.Join(reqArgs, ", ") + ") " + ret +} + +func (g *grpc) generateServerMethod(servName string, method *pb.MethodDescriptorProto) string { + methName := generator.CamelCase(method.GetName()) + hname := fmt.Sprintf("_%s_%s_Handler", servName, methName) + inType := g.typeName(method.GetInputType()) + outType := g.typeName(method.GetOutputType()) + + if !method.GetServerStreaming() && !method.GetClientStreaming() { + g.P("func ", hname, "(srv interface{}, ctx ", contextPkg, ".Context, dec func(interface{}) error) (interface{}, error) {") + g.P("in := new(", inType, ")") + g.P("if err := dec(in); err != nil { return nil, err }") + g.P("out, err := srv.(", servName, "Server).", methName, "(ctx, in)") + g.P("if err != nil { return nil, err }") + g.P("return out, nil") + g.P("}") + g.P() + return hname + } + streamType := unexport(servName) + methName + "Server" + g.P("func ", hname, "(srv interface{}, stream ", grpcPkg, ".ServerStream) error {") + if !method.GetClientStreaming() { + g.P("m := new(", inType, ")") + g.P("if err := stream.RecvMsg(m); err != nil { return err }") + g.P("return srv.(", servName, "Server).", methName, "(m, &", streamType, "{stream})") + } else { + g.P("return srv.(", servName, "Server).", methName, "(&", streamType, "{stream})") + } + g.P("}") + g.P() + + genSend := method.GetServerStreaming() + genSendAndClose := !method.GetServerStreaming() + genRecv := method.GetClientStreaming() + + // Stream auxiliary types and methods. + g.P("type ", servName, "_", methName, "Server interface {") + if genSend { + g.P("Send(*", outType, ") error") + } + if genSendAndClose { + g.P("SendAndClose(*", outType, ") error") + } + if genRecv { + g.P("Recv() (*", inType, ", error)") + } + g.P(grpcPkg, ".ServerStream") + g.P("}") + g.P() + + g.P("type ", streamType, " struct {") + g.P(grpcPkg, ".ServerStream") + g.P("}") + g.P() + + if genSend { + g.P("func (x *", streamType, ") Send(m *", outType, ") error {") + g.P("return x.ServerStream.SendMsg(m)") + g.P("}") + g.P() + } + if genSendAndClose { + g.P("func (x *", streamType, ") SendAndClose(m *", outType, ") error {") + g.P("return x.ServerStream.SendMsg(m)") + g.P("}") + g.P() + } + if genRecv { + g.P("func (x *", streamType, ") Recv() (*", inType, ", error) {") + g.P("m := new(", inType, ")") + g.P("if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err }") + g.P("return m, nil") + g.P("}") + g.P() + } + + return hname +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/marshalto/marshalto.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/marshalto/marshalto.go new file mode 100644 index 0000000000000000000000000000000000000000..c74f15548aafbfdac0c288e0426fb5ba2ba225ea --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/marshalto/marshalto.go @@ -0,0 +1,1267 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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. + +/* +The marshalto plugin generates a Marshal and MarshalTo method for each message. +The `Marshal() ([]byte, error)` method results in the fact that the message +implements the Marshaler interface. +This allows proto.Marshal to be faster by calling the generated Marshal method rather than using reflect to Marshal the struct. + +If is enabled by the following extensions: + + - marshaler + - marshaler_all + +Or the following extensions: + + - unsafe_marshaler + - unsafe_marshaler_all + +That is if you want to use the unsafe package in your generated code. +The speed up using the unsafe package is not very significant. + +The generation of marshalling tests are enabled using one of the following extensions: + + - testgen + - testgen_all + +And benchmarks given it is enabled using one of the following extensions: + + - benchgen + - benchgen_all + +Let us look at: + + github.com/gogo/protobuf/test/example/example.proto + +Btw all the output can be seen at: + + github.com/gogo/protobuf/test/example/* + +The following message: + +option (gogoproto.marshaler_all) = true; + +message B { + option (gogoproto.description) = true; + optional A A = 1 [(gogoproto.nullable) = false, (gogoproto.embed) = true]; + repeated bytes G = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; +} + +given to the marshalto plugin, will generate the following code: + + func (m *B) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil + } + + func (m *B) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintExample(data, i, uint64(m.A.Size())) + n2, err := m.A.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + if len(m.G) > 0 { + for _, msg := range m.G { + data[i] = 0x12 + i++ + i = encodeVarintExample(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil + } + +As shown above Marshal calculates the size of the not yet marshalled message +and allocates the appropriate buffer. +This is followed by calling the MarshalTo method which requires a preallocated buffer. +The MarshalTo method allows a user to rather preallocated a reusable buffer. + +The Size method is generated using the size plugin and the gogoproto.sizer, gogoproto.sizer_all extensions. +The user can also using the generated Size method to check that his reusable buffer is still big enough. + +The generated tests and benchmarks will keep you safe and show that this is really a significant speed improvement. + +*/ +package marshalto + +import ( + "fmt" + "sort" + "strconv" + "strings" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + descriptor "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity" +) + +type NumGen interface { + Next() string + Current() string +} + +type numGen struct { + index int +} + +func NewNumGen() NumGen { + return &numGen{0} +} + +func (this *numGen) Next() string { + this.index++ + return this.Current() +} + +func (this *numGen) Current() string { + return strconv.Itoa(this.index) +} + +type marshalto struct { + *generator.Generator + generator.PluginImports + atleastOne bool + unsafePkg generator.Single + errorsPkg generator.Single + protoPkg generator.Single + sortKeysPkg generator.Single + mathPkg generator.Single + localName string + unsafe bool +} + +func NewMarshal() *marshalto { + return &marshalto{} +} + +func NewUnsafeMarshal() *marshalto { + return &marshalto{unsafe: true} +} + +func (p *marshalto) Name() string { + if p.unsafe { + return "unsafemarshaler" + } + return "marshalto" +} + +func (p *marshalto) Init(g *generator.Generator) { + p.Generator = g +} + +func (p *marshalto) callFixed64(varName ...string) { + p.P(`i = encodeFixed64`, p.localName, `(data, i, uint64(`, strings.Join(varName, ""), `))`) +} + +func (p *marshalto) callFixed32(varName ...string) { + p.P(`i = encodeFixed32`, p.localName, `(data, i, uint32(`, strings.Join(varName, ""), `))`) +} + +func (p *marshalto) callVarint(varName ...string) { + p.P(`i = encodeVarint`, p.localName, `(data, i, uint64(`, strings.Join(varName, ""), `))`) +} + +func (p *marshalto) encodeVarint(varName string) { + p.P(`for `, varName, ` >= 1<<7 {`) + p.In() + p.P(`data[i] = uint8(uint64(`, varName, `)&0x7f|0x80)`) + p.P(varName, ` >>= 7`) + p.P(`i++`) + p.Out() + p.P(`}`) + p.P(`data[i] = uint8(`, varName, `)`) + p.P(`i++`) +} + +func (p *marshalto) encodeFixed64(varName string) { + p.P(`data[i] = uint8(`, varName, `)`) + p.P(`i++`) + p.P(`data[i] = uint8(`, varName, ` >> 8)`) + p.P(`i++`) + p.P(`data[i] = uint8(`, varName, ` >> 16)`) + p.P(`i++`) + p.P(`data[i] = uint8(`, varName, ` >> 24)`) + p.P(`i++`) + p.P(`data[i] = uint8(`, varName, ` >> 32)`) + p.P(`i++`) + p.P(`data[i] = uint8(`, varName, ` >> 40)`) + p.P(`i++`) + p.P(`data[i] = uint8(`, varName, ` >> 48)`) + p.P(`i++`) + p.P(`data[i] = uint8(`, varName, ` >> 56)`) + p.P(`i++`) +} + +func (p *marshalto) unsafeFixed64(varName string, someType string) { + p.P(`*(*`, someType, `)(`, p.unsafePkg.Use(), `.Pointer(&data[i])) = `, varName) + p.P(`i+=8`) +} + +func (p *marshalto) encodeFixed32(varName string) { + p.P(`data[i] = uint8(`, varName, `)`) + p.P(`i++`) + p.P(`data[i] = uint8(`, varName, ` >> 8)`) + p.P(`i++`) + p.P(`data[i] = uint8(`, varName, ` >> 16)`) + p.P(`i++`) + p.P(`data[i] = uint8(`, varName, ` >> 24)`) + p.P(`i++`) +} + +func (p *marshalto) unsafeFixed32(varName string, someType string) { + p.P(`*(*`, someType, `)(`, p.unsafePkg.Use(), `.Pointer(&data[i])) = `, varName) + p.P(`i+=4`) +} + +func (p *marshalto) encodeKey(fieldNumber int32, wireType int) { + x := uint32(fieldNumber)<<3 | uint32(wireType) + i := 0 + keybuf := make([]byte, 0) + for i = 0; x > 127; i++ { + keybuf = append(keybuf, 0x80|uint8(x&0x7F)) + x >>= 7 + } + keybuf = append(keybuf, uint8(x)) + for _, b := range keybuf { + p.P(`data[i] = `, fmt.Sprintf("%#v", b)) + p.P(`i++`) + } +} + +func keySize(fieldNumber int32, wireType int) int { + x := uint32(fieldNumber)<<3 | uint32(wireType) + size := 0 + for size = 0; x > 127; size++ { + x >>= 7 + } + size++ + return size +} + +func wireToType(wire string) int { + switch wire { + case "fixed64": + return proto.WireFixed64 + case "fixed32": + return proto.WireFixed32 + case "varint": + return proto.WireVarint + case "bytes": + return proto.WireBytes + case "group": + return proto.WireBytes + case "zigzag32": + return proto.WireVarint + case "zigzag64": + return proto.WireVarint + } + panic("unreachable") +} + +func (p *marshalto) mapField(numGen NumGen, fieldTyp descriptor.FieldDescriptorProto_Type, varName string) { + switch fieldTyp { + case descriptor.FieldDescriptorProto_TYPE_DOUBLE: + p.callFixed64(p.mathPkg.Use(), `.Float64bits(`, varName, `)`) + case descriptor.FieldDescriptorProto_TYPE_FLOAT: + p.callFixed32(p.mathPkg.Use(), `.Float32bits(`, varName, `)`) + case descriptor.FieldDescriptorProto_TYPE_INT64, + descriptor.FieldDescriptorProto_TYPE_UINT64, + descriptor.FieldDescriptorProto_TYPE_INT32, + descriptor.FieldDescriptorProto_TYPE_UINT32, + descriptor.FieldDescriptorProto_TYPE_ENUM: + p.callVarint(varName) + case descriptor.FieldDescriptorProto_TYPE_FIXED64, + descriptor.FieldDescriptorProto_TYPE_SFIXED64: + p.callFixed64(varName) + case descriptor.FieldDescriptorProto_TYPE_FIXED32, + descriptor.FieldDescriptorProto_TYPE_SFIXED32: + p.callFixed32(varName) + case descriptor.FieldDescriptorProto_TYPE_BOOL: + p.P(`if `, varName, ` {`) + p.In() + p.P(`data[i] = 1`) + p.Out() + p.P(`} else {`) + p.In() + p.P(`data[i] = 0`) + p.Out() + p.P(`}`) + p.P(`i++`) + case descriptor.FieldDescriptorProto_TYPE_STRING, + descriptor.FieldDescriptorProto_TYPE_BYTES: + p.callVarint(`len(`, varName, `)`) + p.P(`i+=copy(data[i:], `, varName, `)`) + case descriptor.FieldDescriptorProto_TYPE_SINT32: + p.callVarint(`(uint32(`, varName, `) << 1) ^ uint32((`, varName, ` >> 31))`) + case descriptor.FieldDescriptorProto_TYPE_SINT64: + p.callVarint(`(uint64(`, varName, `) << 1) ^ uint64((`, varName, ` >> 63))`) + case descriptor.FieldDescriptorProto_TYPE_MESSAGE: + p.callVarint(varName, `.Size()`) + p.P(`n`, numGen.Next(), `, err := `, varName, `.MarshalTo(data[i:])`) + p.P(`if err != nil {`) + p.In() + p.P(`return 0, err`) + p.Out() + p.P(`}`) + p.P(`i+=n`, numGen.Current()) + } +} + +type orderFields []*descriptor.FieldDescriptorProto + +func (this orderFields) Len() int { + return len(this) +} + +func (this orderFields) Less(i, j int) bool { + return this[i].GetNumber() < this[j].GetNumber() +} + +func (this orderFields) Swap(i, j int) { + this[i], this[j] = this[j], this[i] +} + +func (p *marshalto) generateField(proto3 bool, numGen NumGen, file *generator.FileDescriptor, message *generator.Descriptor, field *descriptor.FieldDescriptorProto) { + fieldname := p.GetOneOfFieldName(message, field) + nullable := gogoproto.IsNullable(field) + repeated := field.IsRepeated() + required := field.IsRequired() + if required && nullable { + p.P(`if m.`, fieldname, `== nil {`) + p.In() + if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) { + p.P(`return 0, new(`, p.protoPkg.Use(), `.RequiredNotSetError)`) + } else { + p.P(`return 0, `, p.protoPkg.Use(), `.NewRequiredNotSetError("`, field.GetName(), `")`) + } + p.Out() + p.P(`} else {`) + } else if repeated { + p.P(`if len(m.`, fieldname, `) > 0 {`) + p.In() + } else if ((!proto3 || field.IsMessage()) && nullable) || + (*field.Type == descriptor.FieldDescriptorProto_TYPE_BYTES && !gogoproto.IsCustomType(field)) { + p.P(`if m.`, fieldname, ` != nil {`) + p.In() + } + packed := field.IsPacked() + wireType := field.WireType() + fieldNumber := field.GetNumber() + if packed { + wireType = proto.WireBytes + } + switch *field.Type { + case descriptor.FieldDescriptorProto_TYPE_DOUBLE: + if !p.unsafe { + if packed { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`len(m.`, fieldname, `) * 8`) + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.P(`f`, numGen.Next(), ` := `, p.mathPkg.Use(), `.Float64bits(num)`) + p.encodeFixed64("f" + numGen.Current()) + p.Out() + p.P(`}`) + } else if repeated { + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.P(`f`, numGen.Next(), ` := `, p.mathPkg.Use(), `.Float64bits(num)`) + p.encodeFixed64("f" + numGen.Current()) + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`if m.`, fieldname, ` != 0 {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.callFixed64(p.mathPkg.Use(), `.Float64bits(m.`+fieldname, `)`) + p.Out() + p.P(`}`) + } else if !nullable { + p.encodeKey(fieldNumber, wireType) + p.callFixed64(p.mathPkg.Use(), `.Float64bits(m.`+fieldname, `)`) + } else { + p.encodeKey(fieldNumber, wireType) + p.callFixed64(p.mathPkg.Use(), `.Float64bits(*m.`+fieldname, `)`) + } + } else { + if packed { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`len(m.`, fieldname, `) * 8`) + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.unsafeFixed64("num", "float64") + p.Out() + p.P(`}`) + } else if repeated { + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.unsafeFixed64("num", "float64") + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`if m.`, fieldname, ` != 0 {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.unsafeFixed64(`m.`+fieldname, "float64") + p.Out() + p.P(`}`) + } else if !nullable { + p.encodeKey(fieldNumber, wireType) + p.unsafeFixed64(`m.`+fieldname, "float64") + } else { + p.encodeKey(fieldNumber, wireType) + p.unsafeFixed64(`*m.`+fieldname, `float64`) + } + } + case descriptor.FieldDescriptorProto_TYPE_FLOAT: + if !p.unsafe { + if packed { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`len(m.`, fieldname, `) * 4`) + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.P(`f`, numGen.Next(), ` := `, p.mathPkg.Use(), `.Float32bits(num)`) + p.encodeFixed32("f" + numGen.Current()) + p.Out() + p.P(`}`) + } else if repeated { + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.P(`f`, numGen.Next(), ` := `, p.mathPkg.Use(), `.Float32bits(num)`) + p.encodeFixed32("f" + numGen.Current()) + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`if m.`, fieldname, ` != 0 {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.callFixed32(p.mathPkg.Use(), `.Float32bits(m.`+fieldname, `)`) + p.Out() + p.P(`}`) + } else if !nullable { + p.encodeKey(fieldNumber, wireType) + p.callFixed32(p.mathPkg.Use(), `.Float32bits(m.`+fieldname, `)`) + } else { + p.encodeKey(fieldNumber, wireType) + p.callFixed32(p.mathPkg.Use(), `.Float32bits(*m.`+fieldname, `)`) + } + } else { + if packed { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`len(m.`, fieldname, `) * 4`) + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.unsafeFixed32("num", "float32") + p.Out() + p.P(`}`) + } else if repeated { + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.unsafeFixed32("num", "float32") + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`if m.`, fieldname, ` != 0 {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.unsafeFixed32(`m.`+fieldname, `float32`) + p.Out() + p.P(`}`) + } else if !nullable { + p.encodeKey(fieldNumber, wireType) + p.unsafeFixed32(`m.`+fieldname, `float32`) + } else { + p.encodeKey(fieldNumber, wireType) + p.unsafeFixed32(`*m.`+fieldname, "float32") + } + } + case descriptor.FieldDescriptorProto_TYPE_INT64, + descriptor.FieldDescriptorProto_TYPE_UINT64, + descriptor.FieldDescriptorProto_TYPE_INT32, + descriptor.FieldDescriptorProto_TYPE_UINT32, + descriptor.FieldDescriptorProto_TYPE_ENUM: + if packed { + jvar := "j" + numGen.Next() + p.P(`data`, numGen.Next(), ` := make([]byte, len(m.`, fieldname, `)*10)`) + p.P(`var `, jvar, ` int`) + if *field.Type == descriptor.FieldDescriptorProto_TYPE_INT64 || + *field.Type == descriptor.FieldDescriptorProto_TYPE_INT32 { + p.P(`for _, num1 := range m.`, fieldname, ` {`) + p.In() + p.P(`num := uint64(num1)`) + } else { + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + } + p.P(`for num >= 1<<7 {`) + p.In() + p.P(`data`, numGen.Current(), `[`, jvar, `] = uint8(uint64(num)&0x7f|0x80)`) + p.P(`num >>= 7`) + p.P(jvar, `++`) + p.Out() + p.P(`}`) + p.P(`data`, numGen.Current(), `[`, jvar, `] = uint8(num)`) + p.P(jvar, `++`) + p.Out() + p.P(`}`) + p.encodeKey(fieldNumber, wireType) + p.callVarint(jvar) + p.P(`i += copy(data[i:], data`, numGen.Current(), `[:`, jvar, `])`) + } else if repeated { + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.callVarint("num") + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`if m.`, fieldname, ` != 0 {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.callVarint(`m.`, fieldname) + p.Out() + p.P(`}`) + } else if !nullable { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`m.`, fieldname) + } else { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`*m.`, fieldname) + } + case descriptor.FieldDescriptorProto_TYPE_FIXED64, + descriptor.FieldDescriptorProto_TYPE_SFIXED64: + if !p.unsafe { + if packed { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`len(m.`, fieldname, `) * 8`) + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.encodeFixed64("num") + p.Out() + p.P(`}`) + } else if repeated { + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.encodeFixed64("num") + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`if m.`, fieldname, ` != 0 {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.callFixed64("m." + fieldname) + p.Out() + p.P(`}`) + } else if !nullable { + p.encodeKey(fieldNumber, wireType) + p.callFixed64("m." + fieldname) + } else { + p.encodeKey(fieldNumber, wireType) + p.callFixed64("*m." + fieldname) + } + } else { + typeName := "int64" + if *field.Type == descriptor.FieldDescriptorProto_TYPE_FIXED64 { + typeName = "uint64" + } + if packed { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`len(m.`, fieldname, `) * 8`) + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.unsafeFixed64("num", typeName) + p.Out() + p.P(`}`) + } else if repeated { + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.unsafeFixed64("num", typeName) + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`if m.`, fieldname, ` != 0 {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.unsafeFixed64("m."+fieldname, typeName) + p.Out() + p.P(`}`) + } else if !nullable { + p.encodeKey(fieldNumber, wireType) + p.unsafeFixed64("m."+fieldname, typeName) + } else { + p.encodeKey(fieldNumber, wireType) + p.unsafeFixed64("*m."+fieldname, typeName) + } + } + case descriptor.FieldDescriptorProto_TYPE_FIXED32, + descriptor.FieldDescriptorProto_TYPE_SFIXED32: + if !p.unsafe { + if packed { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`len(m.`, fieldname, `) * 4`) + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.encodeFixed32("num") + p.Out() + p.P(`}`) + } else if repeated { + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.encodeFixed32("num") + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`if m.`, fieldname, ` != 0 {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.callFixed32("m." + fieldname) + p.Out() + p.P(`}`) + } else if !nullable { + p.encodeKey(fieldNumber, wireType) + p.callFixed32("m." + fieldname) + } else { + p.encodeKey(fieldNumber, wireType) + p.callFixed32("*m." + fieldname) + } + } else { + typeName := "int32" + if *field.Type == descriptor.FieldDescriptorProto_TYPE_FIXED32 { + typeName = "uint32" + } + if packed { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`len(m.`, fieldname, `) * 4`) + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.unsafeFixed32("num", typeName) + p.Out() + p.P(`}`) + } else if repeated { + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.unsafeFixed32("num", typeName) + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`if m.`, fieldname, ` != 0 {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.unsafeFixed32("m."+fieldname, typeName) + p.Out() + p.P(`}`) + } else if !nullable { + p.encodeKey(fieldNumber, wireType) + p.unsafeFixed32("m."+fieldname, typeName) + } else { + p.encodeKey(fieldNumber, wireType) + p.unsafeFixed32("*m."+fieldname, typeName) + } + } + case descriptor.FieldDescriptorProto_TYPE_BOOL: + if packed { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`len(m.`, fieldname, `)`) + p.P(`for _, b := range m.`, fieldname, ` {`) + p.In() + p.P(`if b {`) + p.In() + p.P(`data[i] = 1`) + p.Out() + p.P(`} else {`) + p.In() + p.P(`data[i] = 0`) + p.Out() + p.P(`}`) + p.P(`i++`) + p.Out() + p.P(`}`) + } else if repeated { + p.P(`for _, b := range m.`, fieldname, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.P(`if b {`) + p.In() + p.P(`data[i] = 1`) + p.Out() + p.P(`} else {`) + p.In() + p.P(`data[i] = 0`) + p.Out() + p.P(`}`) + p.P(`i++`) + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`if m.`, fieldname, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.P(`if m.`, fieldname, ` {`) + p.In() + p.P(`data[i] = 1`) + p.Out() + p.P(`} else {`) + p.In() + p.P(`data[i] = 0`) + p.Out() + p.P(`}`) + p.P(`i++`) + p.Out() + p.P(`}`) + } else if !nullable { + p.encodeKey(fieldNumber, wireType) + p.P(`if m.`, fieldname, ` {`) + p.In() + p.P(`data[i] = 1`) + p.Out() + p.P(`} else {`) + p.In() + p.P(`data[i] = 0`) + p.Out() + p.P(`}`) + p.P(`i++`) + } else { + p.encodeKey(fieldNumber, wireType) + p.P(`if *m.`, fieldname, ` {`) + p.In() + p.P(`data[i] = 1`) + p.Out() + p.P(`} else {`) + p.In() + p.P(`data[i] = 0`) + p.Out() + p.P(`}`) + p.P(`i++`) + } + case descriptor.FieldDescriptorProto_TYPE_STRING: + if repeated { + p.P(`for _, s := range m.`, fieldname, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.P(`l = len(s)`) + p.encodeVarint("l") + p.P(`i+=copy(data[i:], s)`) + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`if len(m.`, fieldname, `) > 0 {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.callVarint(`len(m.`, fieldname, `)`) + p.P(`i+=copy(data[i:], m.`, fieldname, `)`) + p.Out() + p.P(`}`) + } else if !nullable { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`len(m.`, fieldname, `)`) + p.P(`i+=copy(data[i:], m.`, fieldname, `)`) + } else { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`len(*m.`, fieldname, `)`) + p.P(`i+=copy(data[i:], *m.`, fieldname, `)`) + } + case descriptor.FieldDescriptorProto_TYPE_GROUP: + panic(fmt.Errorf("marshaler does not support group %v", fieldname)) + case descriptor.FieldDescriptorProto_TYPE_MESSAGE: + if generator.IsMap(file.FileDescriptorProto, field) { + mapMsg := generator.GetMap(file.FileDescriptorProto, field) + keyField, valueField := mapMsg.GetMapFields() + keysName := `keysFor` + fieldname + keygoTyp, keywire := p.GoType(nil, keyField) + keygoTyp = strings.Replace(keygoTyp, "*", "", 1) + _, valuewire := p.GoType(nil, valueField) + keyCapTyp := generator.CamelCase(keygoTyp) + keyKeySize := keySize(1, wireToType(keywire)) + valueKeySize := keySize(2, wireToType(valuewire)) + p.P(keysName, ` := make([]`, keygoTyp, `, 0, len(m.`, fieldname, `))`) + p.P(`for k, _ := range m.`, fieldname, ` {`) + p.In() + p.P(keysName, ` = append(`, keysName, `, k)`) + p.Out() + p.P(`}`) + p.P(p.sortKeysPkg.Use(), `.`, keyCapTyp, `s(`, keysName, `)`) + p.P(`for _, k := range `, keysName, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + sum := []string{strconv.Itoa(keyKeySize)} + switch keyField.GetType() { + case descriptor.FieldDescriptorProto_TYPE_DOUBLE, + descriptor.FieldDescriptorProto_TYPE_FIXED64, + descriptor.FieldDescriptorProto_TYPE_SFIXED64: + sum = append(sum, `8`) + case descriptor.FieldDescriptorProto_TYPE_FLOAT, + descriptor.FieldDescriptorProto_TYPE_FIXED32, + descriptor.FieldDescriptorProto_TYPE_SFIXED32: + sum = append(sum, `4`) + case descriptor.FieldDescriptorProto_TYPE_INT64, + descriptor.FieldDescriptorProto_TYPE_UINT64, + descriptor.FieldDescriptorProto_TYPE_UINT32, + descriptor.FieldDescriptorProto_TYPE_ENUM, + descriptor.FieldDescriptorProto_TYPE_INT32: + sum = append(sum, `sov`+p.localName+`(uint64(k))`) + case descriptor.FieldDescriptorProto_TYPE_BOOL: + sum = append(sum, `1`) + case descriptor.FieldDescriptorProto_TYPE_STRING, + descriptor.FieldDescriptorProto_TYPE_BYTES: + sum = append(sum, `len(k)+sov`+p.localName+`(uint64(len(k)))`) + case descriptor.FieldDescriptorProto_TYPE_SINT32, + descriptor.FieldDescriptorProto_TYPE_SINT64: + sum = append(sum, `soz`+p.localName+`(uint64(k))`) + } + p.P(`v := m.`, fieldname, `[k]`) + sum = append(sum, strconv.Itoa(valueKeySize)) + switch valueField.GetType() { + case descriptor.FieldDescriptorProto_TYPE_DOUBLE, + descriptor.FieldDescriptorProto_TYPE_FIXED64, + descriptor.FieldDescriptorProto_TYPE_SFIXED64: + sum = append(sum, strconv.Itoa(8)) + case descriptor.FieldDescriptorProto_TYPE_FLOAT, + descriptor.FieldDescriptorProto_TYPE_FIXED32, + descriptor.FieldDescriptorProto_TYPE_SFIXED32: + sum = append(sum, strconv.Itoa(4)) + case descriptor.FieldDescriptorProto_TYPE_INT64, + descriptor.FieldDescriptorProto_TYPE_UINT64, + descriptor.FieldDescriptorProto_TYPE_UINT32, + descriptor.FieldDescriptorProto_TYPE_ENUM, + descriptor.FieldDescriptorProto_TYPE_INT32: + sum = append(sum, `sov`+p.localName+`(uint64(v))`) + case descriptor.FieldDescriptorProto_TYPE_BOOL: + sum = append(sum, `1`) + case descriptor.FieldDescriptorProto_TYPE_STRING, + descriptor.FieldDescriptorProto_TYPE_BYTES: + sum = append(sum, `len(v)+sov`+p.localName+`(uint64(len(v)))`) + case descriptor.FieldDescriptorProto_TYPE_SINT32, + descriptor.FieldDescriptorProto_TYPE_SINT64: + sum = append(sum, `soz`+p.localName+`(uint64(v))`) + case descriptor.FieldDescriptorProto_TYPE_MESSAGE: + p.P(`if v == nil {`) + p.In() + p.P(`return 0, `, p.errorsPkg.Use(), `.New("proto: map has nil element")`) + p.Out() + p.P(`}`) + p.P(`msgSize := v.Size()`) + sum = append(sum, `msgSize + sov`+p.localName+`(uint64(msgSize))`) + } + p.P(`mapSize := `, strings.Join(sum, " + ")) + p.callVarint("mapSize") + p.encodeKey(1, wireToType(keywire)) + p.mapField(numGen, keyField.GetType(), "k") + p.encodeKey(2, wireToType(valuewire)) + p.mapField(numGen, valueField.GetType(), "v") + p.Out() + p.P(`}`) + } else if repeated { + p.P(`for _, msg := range m.`, fieldname, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.callVarint("msg.Size()") + p.P(`n, err := msg.MarshalTo(data[i:])`) + p.P(`if err != nil {`) + p.In() + p.P(`return 0, err`) + p.Out() + p.P(`}`) + p.P(`i+=n`) + p.Out() + p.P(`}`) + } else { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`m.`, fieldname, `.Size()`) + p.P(`n`, numGen.Next(), `, err := m.`, fieldname, `.MarshalTo(data[i:])`) + p.P(`if err != nil {`) + p.In() + p.P(`return 0, err`) + p.Out() + p.P(`}`) + p.P(`i+=n`, numGen.Current()) + } + case descriptor.FieldDescriptorProto_TYPE_BYTES: + if !gogoproto.IsCustomType(field) { + if repeated { + p.P(`for _, b := range m.`, fieldname, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.callVarint("len(b)") + p.P(`i+=copy(data[i:], b)`) + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`if len(m.`, fieldname, `) > 0 {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.callVarint(`len(m.`, fieldname, `)`) + p.P(`i+=copy(data[i:], m.`, fieldname, `)`) + p.Out() + p.P(`}`) + } else { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`len(m.`, fieldname, `)`) + p.P(`i+=copy(data[i:], m.`, fieldname, `)`) + } + } else { + if repeated { + p.P(`for _, msg := range m.`, fieldname, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.callVarint(`msg.Size()`) + p.P(`n, err := msg.MarshalTo(data[i:])`) + p.P(`if err != nil {`) + p.In() + p.P(`return 0, err`) + p.Out() + p.P(`}`) + p.P(`i+=n`) + p.Out() + p.P(`}`) + } else { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`m.`, fieldname, `.Size()`) + p.P(`n`, numGen.Next(), `, err := m.`, fieldname, `.MarshalTo(data[i:])`) + p.P(`if err != nil {`) + p.In() + p.P(`return 0, err`) + p.Out() + p.P(`}`) + p.P(`i+=n`, numGen.Current()) + } + } + case descriptor.FieldDescriptorProto_TYPE_SINT32: + if packed { + datavar := "data" + numGen.Next() + jvar := "j" + numGen.Next() + p.P(datavar, ` := make([]byte, len(m.`, fieldname, ")*5)") + p.P(`var `, jvar, ` int`) + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + xvar := "x" + numGen.Next() + p.P(xvar, ` := (uint32(num) << 1) ^ uint32((num >> 31))`) + p.P(`for `, xvar, ` >= 1<<7 {`) + p.In() + p.P(datavar, `[`, jvar, `] = uint8(uint64(`, xvar, `)&0x7f|0x80)`) + p.P(jvar, `++`) + p.P(xvar, ` >>= 7`) + p.Out() + p.P(`}`) + p.P(datavar, `[`, jvar, `] = uint8(`, xvar, `)`) + p.P(jvar, `++`) + p.Out() + p.P(`}`) + p.encodeKey(fieldNumber, wireType) + p.callVarint(jvar) + p.P(`i+=copy(data[i:], `, datavar, `[:`, jvar, `])`) + } else if repeated { + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.P(`x`, numGen.Next(), ` := (uint32(num) << 1) ^ uint32((num >> 31))`) + p.encodeVarint("x" + numGen.Current()) + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`if m.`, fieldname, ` != 0 {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.callVarint(`(uint32(m.`, fieldname, `) << 1) ^ uint32((m.`, fieldname, ` >> 31))`) + p.Out() + p.P(`}`) + } else if !nullable { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`(uint32(m.`, fieldname, `) << 1) ^ uint32((m.`, fieldname, ` >> 31))`) + } else { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`(uint32(*m.`, fieldname, `) << 1) ^ uint32((*m.`, fieldname, ` >> 31))`) + } + case descriptor.FieldDescriptorProto_TYPE_SINT64: + if packed { + jvar := "j" + numGen.Next() + xvar := "x" + numGen.Next() + datavar := "data" + numGen.Next() + p.P(`var `, jvar, ` int`) + p.P(datavar, ` := make([]byte, len(m.`, fieldname, `)*10)`) + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.P(xvar, ` := (uint64(num) << 1) ^ uint64((num >> 63))`) + p.P(`for `, xvar, ` >= 1<<7 {`) + p.In() + p.P(datavar, `[`, jvar, `] = uint8(uint64(`, xvar, `)&0x7f|0x80)`) + p.P(jvar, `++`) + p.P(xvar, ` >>= 7`) + p.Out() + p.P(`}`) + p.P(datavar, `[`, jvar, `] = uint8(`, xvar, `)`) + p.P(jvar, `++`) + p.Out() + p.P(`}`) + p.encodeKey(fieldNumber, wireType) + p.callVarint(jvar) + p.P(`i+=copy(data[i:], `, datavar, `[:`, jvar, `])`) + } else if repeated { + p.P(`for _, num := range m.`, fieldname, ` {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.P(`x`, numGen.Next(), ` := (uint64(num) << 1) ^ uint64((num >> 63))`) + p.encodeVarint("x" + numGen.Current()) + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`if m.`, fieldname, ` != 0 {`) + p.In() + p.encodeKey(fieldNumber, wireType) + p.callVarint(`(uint64(m.`, fieldname, `) << 1) ^ uint64((m.`, fieldname, ` >> 63))`) + p.Out() + p.P(`}`) + } else if !nullable { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`(uint64(m.`, fieldname, `) << 1) ^ uint64((m.`, fieldname, ` >> 63))`) + } else { + p.encodeKey(fieldNumber, wireType) + p.callVarint(`(uint64(*m.`, fieldname, `) << 1) ^ uint64((*m.`, fieldname, ` >> 63))`) + } + default: + panic("not implemented") + } + if (required && nullable) || + ((!proto3 || field.IsMessage()) && nullable) || + repeated || + (*field.Type == descriptor.FieldDescriptorProto_TYPE_BYTES && !gogoproto.IsCustomType(field)) { + p.Out() + p.P(`}`) + } +} + +func (p *marshalto) Generate(file *generator.FileDescriptor) { + numGen := NewNumGen() + p.PluginImports = generator.NewPluginImports(p.Generator) + p.atleastOne = false + p.localName = generator.FileName(file) + + p.mathPkg = p.NewImport("math") + p.sortKeysPkg = p.NewImport("github.com/gogo/protobuf/sortkeys") + p.protoPkg = p.NewImport("github.com/gogo/protobuf/proto") + if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) { + p.protoPkg = p.NewImport("github.com/golang/protobuf/proto") + } + p.unsafePkg = p.NewImport("unsafe") + p.errorsPkg = p.NewImport("errors") + + for _, message := range file.Messages() { + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + if p.unsafe { + if !gogoproto.IsUnsafeMarshaler(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if gogoproto.IsMarshaler(file.FileDescriptorProto, message.DescriptorProto) { + panic(fmt.Sprintf("unsafe_marshaler and marshalto enabled for %v", ccTypeName)) + } + } + if !p.unsafe { + if !gogoproto.IsMarshaler(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if gogoproto.IsUnsafeMarshaler(file.FileDescriptorProto, message.DescriptorProto) { + panic(fmt.Sprintf("unsafe_marshaler and marshalto enabled for %v", ccTypeName)) + } + } + p.atleastOne = true + + p.P(`func (m *`, ccTypeName, `) Marshal() (data []byte, err error) {`) + p.In() + p.P(`size := m.Size()`) + p.P(`data = make([]byte, size)`) + p.P(`n, err := m.MarshalTo(data)`) + p.P(`if err != nil {`) + p.In() + p.P(`return nil, err`) + p.Out() + p.P(`}`) + p.P(`return data[:n], nil`) + p.Out() + p.P(`}`) + p.P(``) + p.P(`func (m *`, ccTypeName, `) MarshalTo(data []byte) (int, error) {`) + p.In() + p.P(`var i int`) + p.P(`_ = i`) + p.P(`var l int`) + p.P(`_ = l`) + fields := orderFields(message.GetField()) + sort.Sort(fields) + oneofs := make(map[string]struct{}) + for _, field := range message.Field { + oneof := field.OneofIndex != nil + if !oneof { + proto3 := gogoproto.IsProto3(file.FileDescriptorProto) + p.generateField(proto3, numGen, file, message, field) + } else { + fieldname := p.GetFieldName(message, field) + if _, ok := oneofs[fieldname]; !ok { + oneofs[fieldname] = struct{}{} + p.P(`if m.`, fieldname, ` != nil {`) + p.In() + p.P(`nn`, numGen.Next(), `, err := m.`, fieldname, `.MarshalTo(data[i:])`) + p.P(`if err != nil {`) + p.In() + p.P(`return 0, err`) + p.Out() + p.P(`}`) + p.P(`i+=nn`, numGen.Current()) + p.Out() + p.P(`}`) + } + } + } + if message.DescriptorProto.HasExtension() { + if gogoproto.HasExtensionsMap(file.FileDescriptorProto, message.DescriptorProto) { + p.P(`if len(m.XXX_extensions) > 0 {`) + p.In() + p.P(`n, err := `, p.protoPkg.Use(), `.EncodeExtensionMap(m.XXX_extensions, data[i:])`) + p.P(`if err != nil {`) + p.In() + p.P(`return 0, err`) + p.Out() + p.P(`}`) + p.P(`i+=n`) + p.Out() + p.P(`}`) + } else { + p.P(`if m.XXX_extensions != nil {`) + p.In() + p.P(`i+=copy(data[i:], m.XXX_extensions)`) + p.Out() + p.P(`}`) + } + } + if gogoproto.HasUnrecognized(file.FileDescriptorProto, message.DescriptorProto) { + p.P(`if m.XXX_unrecognized != nil {`) + p.In() + p.P(`i+=copy(data[i:], m.XXX_unrecognized)`) + p.Out() + p.P(`}`) + } + + p.P(`return i, nil`) + p.Out() + p.P(`}`) + p.P() + + //Generate MarshalTo methods for oneof fields + m := proto.Clone(message.DescriptorProto).(*descriptor.DescriptorProto) + for _, field := range m.Field { + oneof := field.OneofIndex != nil + if !oneof { + continue + } + ccTypeName := p.OneOfTypeName(message, field) + p.P(`func (m *`, ccTypeName, `) MarshalTo(data []byte) (int, error) {`) + p.In() + p.P(`i := 0`) + vanity.TurnOffNullableForNativeTypesWithoutDefaultsOnly(field) + p.generateField(false, numGen, file, message, field) + p.P(`return i, nil`) + p.Out() + p.P(`}`) + } + } + + if p.atleastOne { + p.P(`func encodeFixed64`, p.localName, `(data []byte, offset int, v uint64) int {`) + p.In() + p.P(`data[offset] = uint8(v)`) + p.P(`data[offset+1] = uint8(v >> 8)`) + p.P(`data[offset+2] = uint8(v >> 16)`) + p.P(`data[offset+3] = uint8(v >> 24)`) + p.P(`data[offset+4] = uint8(v >> 32)`) + p.P(`data[offset+5] = uint8(v >> 40)`) + p.P(`data[offset+6] = uint8(v >> 48)`) + p.P(`data[offset+7] = uint8(v >> 56)`) + p.P(`return offset+8`) + p.Out() + p.P(`}`) + + p.P(`func encodeFixed32`, p.localName, `(data []byte, offset int, v uint32) int {`) + p.In() + p.P(`data[offset] = uint8(v)`) + p.P(`data[offset+1] = uint8(v >> 8)`) + p.P(`data[offset+2] = uint8(v >> 16)`) + p.P(`data[offset+3] = uint8(v >> 24)`) + p.P(`return offset+4`) + p.Out() + p.P(`}`) + + p.P(`func encodeVarint`, p.localName, `(data []byte, offset int, v uint64) int {`) + p.In() + p.P(`for v >= 1<<7 {`) + p.In() + p.P(`data[offset] = uint8(v&0x7f|0x80)`) + p.P(`v >>= 7`) + p.P(`offset++`) + p.Out() + p.P(`}`) + p.P(`data[offset] = uint8(v)`) + p.P(`return offset+1`) + p.Out() + p.P(`}`) + } + +} + +func init() { + generator.RegisterPlugin(NewMarshal()) + generator.RegisterPlugin(NewUnsafeMarshal()) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/oneofcheck/oneofcheck.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/oneofcheck/oneofcheck.go new file mode 100644 index 0000000000000000000000000000000000000000..df6b8b78b8ba8c701f148556340295aaad28bd05 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/oneofcheck/oneofcheck.go @@ -0,0 +1,91 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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. + +/* +The oneofcheck plugin is used to check whether oneof is not used incorrectly. +For instance: +An error is caused if a oneof field: + - is used in a face + - is an embedded field + +*/ +package oneofcheck + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" + "fmt" + "os" +) + +type plugin struct { + *generator.Generator +} + +func NewPlugin() *plugin { + return &plugin{} +} + +func (p *plugin) Name() string { + return "oneofcheck" +} + +func (p *plugin) Init(g *generator.Generator) { + p.Generator = g +} + +func (p *plugin) Generate(file *generator.FileDescriptor) { + for _, msg := range file.Messages() { + face := gogoproto.IsFace(file.FileDescriptorProto, msg.DescriptorProto) + for _, field := range msg.GetField() { + if field.OneofIndex == nil { + continue + } + if face { + fmt.Fprintf(os.Stderr, "ERROR: field %v.%v cannot be in a face and oneof\n", generator.CamelCase(*msg.Name), generator.CamelCase(*field.Name)) + os.Exit(1) + } + if gogoproto.IsEmbed(field) { + fmt.Fprintf(os.Stderr, "ERROR: field %v.%v cannot be in an oneof and an embedded field\n", generator.CamelCase(*msg.Name), generator.CamelCase(*field.Name)) + os.Exit(1) + } + if !gogoproto.IsNullable(field) { + fmt.Fprintf(os.Stderr, "ERROR: field %v.%v cannot be in an oneof and a non-nullable field\n", generator.CamelCase(*msg.Name), generator.CamelCase(*field.Name)) + os.Exit(1) + } + if gogoproto.IsUnion(file.FileDescriptorProto, msg.DescriptorProto) { + fmt.Fprintf(os.Stderr, "ERROR: field %v.%v cannot be in an oneof and in an union (deprecated)\n", generator.CamelCase(*msg.Name), generator.CamelCase(*field.Name)) + os.Exit(1) + } + } + } +} + +func (p *plugin) GenerateImports(*generator.FileDescriptor) {} + +func init() { + generator.RegisterPlugin(NewPlugin()) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/populate/populate.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/populate/populate.go new file mode 100644 index 0000000000000000000000000000000000000000..7396f84c336018c4d2c01d085f6285e46c35844d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/populate/populate.go @@ -0,0 +1,747 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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. + +/* +The populate plugin generates a NewPopulated function. +This function returns a newly populated structure. + +It is enabled by the following extensions: + + - populate + - populate_all + +Let us look at: + + github.com/gogo/protobuf/test/example/example.proto + +Btw all the output can be seen at: + + github.com/gogo/protobuf/test/example/* + +The following message: + + option (gogoproto.populate_all) = true; + + message B { + optional A A = 1 [(gogoproto.nullable) = false, (gogoproto.embed) = true]; + repeated bytes G = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; + } + +given to the populate plugin, will generate code the following code: + + func NewPopulatedB(r randyExample, easy bool) *B { + this := &B{} + v2 := NewPopulatedA(r, easy) + this.A = *v2 + if r.Intn(10) != 0 { + v3 := r.Intn(10) + this.G = make([]github_com_gogo_protobuf_test_custom.Uint128, v3) + for i := 0; i < v3; i++ { + v4 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.G[i] = *v4 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedExample(r, 3) + } + return this + } + +The idea that is useful for testing. +Most of the other plugins' generated test code uses it. +You will still be able to use the generated test code of other packages +if you turn off the popluate plugin and write your own custom NewPopulated function. + +If the easy flag is not set the XXX_unrecognized and XXX_extensions fields are also populated. +These have caused problems with JSON marshalling and unmarshalling tests. + +*/ +package populate + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + descriptor "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity" + "fmt" + "math" + "strconv" + "strings" +) + +type VarGen interface { + Next() string + Current() string +} + +type varGen struct { + index int64 +} + +func NewVarGen() VarGen { + return &varGen{0} +} + +func (this *varGen) Next() string { + this.index++ + return fmt.Sprintf("v%d", this.index) +} + +func (this *varGen) Current() string { + return fmt.Sprintf("v%d", this.index) +} + +type plugin struct { + *generator.Generator + generator.PluginImports + varGen VarGen + atleastOne bool + localName string +} + +func NewPlugin() *plugin { + return &plugin{} +} + +func (p *plugin) Name() string { + return "populate" +} + +func (p *plugin) Init(g *generator.Generator) { + p.Generator = g +} + +func value(typeName string, fieldType descriptor.FieldDescriptorProto_Type) string { + switch fieldType { + case descriptor.FieldDescriptorProto_TYPE_DOUBLE: + return typeName + "(r.Float64())" + case descriptor.FieldDescriptorProto_TYPE_FLOAT: + return typeName + "(r.Float32())" + case descriptor.FieldDescriptorProto_TYPE_INT64, + descriptor.FieldDescriptorProto_TYPE_SFIXED64, + descriptor.FieldDescriptorProto_TYPE_SINT64: + return typeName + "(r.Int63())" + case descriptor.FieldDescriptorProto_TYPE_UINT64, + descriptor.FieldDescriptorProto_TYPE_FIXED64: + return typeName + "(uint64(r.Uint32()))" + case descriptor.FieldDescriptorProto_TYPE_INT32, + descriptor.FieldDescriptorProto_TYPE_SINT32, + descriptor.FieldDescriptorProto_TYPE_SFIXED32, + descriptor.FieldDescriptorProto_TYPE_ENUM: + return typeName + "(r.Int31())" + case descriptor.FieldDescriptorProto_TYPE_UINT32, + descriptor.FieldDescriptorProto_TYPE_FIXED32: + return typeName + "(r.Uint32())" + case descriptor.FieldDescriptorProto_TYPE_BOOL: + return typeName + `(bool(r.Intn(2) == 0))` + case descriptor.FieldDescriptorProto_TYPE_STRING, + descriptor.FieldDescriptorProto_TYPE_GROUP, + descriptor.FieldDescriptorProto_TYPE_MESSAGE, + descriptor.FieldDescriptorProto_TYPE_BYTES: + } + panic(fmt.Errorf("unexpected type %v", typeName)) +} + +func negative(fieldType descriptor.FieldDescriptorProto_Type) bool { + switch fieldType { + case descriptor.FieldDescriptorProto_TYPE_UINT64, + descriptor.FieldDescriptorProto_TYPE_FIXED64, + descriptor.FieldDescriptorProto_TYPE_UINT32, + descriptor.FieldDescriptorProto_TYPE_FIXED32, + descriptor.FieldDescriptorProto_TYPE_BOOL: + return false + } + return true +} + +func getFuncName(goTypName string) string { + funcName := "NewPopulated" + goTypName + goTypNames := strings.Split(goTypName, ".") + if len(goTypNames) == 2 { + funcName = goTypNames[0] + ".NewPopulated" + goTypNames[1] + } else if len(goTypNames) != 1 { + panic(fmt.Errorf("unreachable: too many dots in %v", goTypName)) + } + return funcName +} + +func getFuncCall(goTypName string) string { + funcName := getFuncName(goTypName) + funcCall := funcName + "(r, easy)" + return funcCall +} + +func getCustomFuncCall(goTypName string) string { + funcName := getFuncName(goTypName) + funcCall := funcName + "(r)" + return funcCall +} + +func (p *plugin) getEnumVal(field *descriptor.FieldDescriptorProto, goTyp string) string { + enum := p.ObjectNamed(field.GetTypeName()).(*generator.EnumDescriptor) + l := len(enum.Value) + values := make([]string, l) + for i := range enum.Value { + values[i] = strconv.Itoa(int(*enum.Value[i].Number)) + } + arr := "[]int32{" + strings.Join(values, ",") + "}" + val := strings.Join([]string{generator.GoTypeToName(goTyp), `(`, arr, `[r.Intn(`, fmt.Sprintf("%d", l), `)])`}, "") + return val +} + +func (p *plugin) GenerateField(file *generator.FileDescriptor, message *generator.Descriptor, field *descriptor.FieldDescriptorProto) { + proto3 := gogoproto.IsProto3(file.FileDescriptorProto) + goTyp, _ := p.GoType(message, field) + fieldname := p.GetOneOfFieldName(message, field) + goTypName := generator.GoTypeToName(goTyp) + if generator.IsMap(file.FileDescriptorProto, field) { + mapmsg := generator.GetMap(file.FileDescriptorProto, field) + mapkey, mapvalue := mapmsg.GetMapFields() + keygoTyp, _ := p.GoType(nil, mapkey) + valuegoTyp, _ := p.GoType(nil, mapvalue) + keytypName := generator.GoTypeToName(keygoTyp) + valuetypName := generator.GoTypeToName(valuegoTyp) + mapvaluegoType := valuegoTyp + if !mapvalue.IsMessage() { + mapvaluegoType = strings.Replace(mapvaluegoType, "*", "", 1) + } + p.P(p.varGen.Next(), ` := r.Intn(10)`) + p.P(`this.`, fieldname, ` = make(map[`, strings.Replace(keygoTyp, "*", "", 1), `]`, mapvaluegoType, `)`) + p.P(`for i := 0; i < `, p.varGen.Current(), `; i++ {`) + p.In() + keyval := "" + if mapkey.IsString() { + keyval = fmt.Sprintf("randString%v(r)", p.localName) + } else { + keyval = value(keytypName, mapkey.GetType()) + } + if mapvalue.IsMessage() || p.IsGroup(field) { + s := `this.` + fieldname + `[` + keyval + `]` + ` = ` + goTypName := generator.GoTypeToName(valuegoTyp) + funcCall := getFuncCall(goTypName) + s += funcCall + p.P(s) + } else if mapvalue.IsEnum() { + s := `this.` + fieldname + `[` + keyval + `]` + ` = ` + p.getEnumVal(mapvalue, valuegoTyp) + p.P(s) + } else if mapvalue.IsBytes() { + count := p.varGen.Next() + p.P(count, ` := r.Intn(100)`) + p.P(p.varGen.Next(), ` := `, keyval) + p.P(`this.`, fieldname, `[`, p.varGen.Current(), `] = make(`, valuegoTyp, `, `, count, `)`) + p.P(`for i := 0; i < `, count, `; i++ {`) + p.In() + p.P(`this.`, fieldname, `[`, p.varGen.Current(), `][i] = byte(r.Intn(256))`) + p.Out() + p.P(`}`) + } else if mapvalue.IsString() { + s := `this.` + fieldname + `[` + keyval + `]` + ` = ` + fmt.Sprintf("randString%v(r)", p.localName) + p.P(s) + } else { + p.P(p.varGen.Next(), ` := `, keyval) + p.P(`this.`, fieldname, `[`, p.varGen.Current(), `] = `, value(valuetypName, mapvalue.GetType())) + if negative(mapvalue.GetType()) { + p.P(`if r.Intn(2) == 0 {`) + p.In() + p.P(`this.`, fieldname, `[`, p.varGen.Current(), `] *= -1`) + p.Out() + p.P(`}`) + } + } + p.Out() + p.P(`}`) + } else if field.IsMessage() || p.IsGroup(field) { + funcCall := getFuncCall(goTypName) + if field.IsRepeated() { + p.P(p.varGen.Next(), ` := r.Intn(10)`) + p.P(`this.`, fieldname, ` = make(`, goTyp, `, `, p.varGen.Current(), `)`) + p.P(`for i := 0; i < `, p.varGen.Current(), `; i++ {`) + p.In() + if gogoproto.IsNullable(field) { + p.P(`this.`, fieldname, `[i] = `, funcCall) + } else { + p.P(p.varGen.Next(), `:= `, funcCall) + p.P(`this.`, fieldname, `[i] = *`, p.varGen.Current()) + } + p.Out() + p.P(`}`) + } else { + if gogoproto.IsNullable(field) { + p.P(`this.`, fieldname, ` = `, funcCall) + } else { + p.P(p.varGen.Next(), `:= `, funcCall) + p.P(`this.`, fieldname, ` = *`, p.varGen.Current()) + } + } + } else { + if field.IsEnum() { + val := p.getEnumVal(field, goTyp) + if field.IsRepeated() { + p.P(p.varGen.Next(), ` := r.Intn(10)`) + p.P(`this.`, fieldname, ` = make(`, goTyp, `, `, p.varGen.Current(), `)`) + p.P(`for i := 0; i < `, p.varGen.Current(), `; i++ {`) + p.In() + p.P(`this.`, fieldname, `[i] = `, val) + p.Out() + p.P(`}`) + } else if !gogoproto.IsNullable(field) || proto3 { + p.P(`this.`, fieldname, ` = `, val) + } else { + p.P(p.varGen.Next(), ` := `, val) + p.P(`this.`, fieldname, ` = &`, p.varGen.Current()) + } + } else if gogoproto.IsCustomType(field) { + funcCall := getCustomFuncCall(goTypName) + if field.IsRepeated() { + p.P(p.varGen.Next(), ` := r.Intn(10)`) + p.P(`this.`, fieldname, ` = make(`, goTyp, `, `, p.varGen.Current(), `)`) + p.P(`for i := 0; i < `, p.varGen.Current(), `; i++ {`) + p.In() + p.P(p.varGen.Next(), `:= `, funcCall) + p.P(`this.`, fieldname, `[i] = *`, p.varGen.Current()) + p.Out() + p.P(`}`) + } else if gogoproto.IsNullable(field) { + p.P(`this.`, fieldname, ` = `, funcCall) + } else { + p.P(p.varGen.Next(), `:= `, funcCall) + p.P(`this.`, fieldname, ` = *`, p.varGen.Current()) + } + } else if field.IsBytes() { + if field.IsRepeated() { + p.P(p.varGen.Next(), ` := r.Intn(100)`) + p.P(`this.`, fieldname, ` = make(`, goTyp, `, `, p.varGen.Current(), `)`) + p.P(`for i := 0; i < `, p.varGen.Current(), `; i++ {`) + p.In() + p.P(p.varGen.Next(), ` := r.Intn(100)`) + p.P(`this.`, fieldname, `[i] = make([]byte,`, p.varGen.Current(), `)`) + p.P(`for j := 0; j < `, p.varGen.Current(), `; j++ {`) + p.In() + p.P(`this.`, fieldname, `[i][j] = byte(r.Intn(256))`) + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + } else { + p.P(p.varGen.Next(), ` := r.Intn(100)`) + p.P(`this.`, fieldname, ` = make(`, goTyp, `, `, p.varGen.Current(), `)`) + p.P(`for i := 0; i < `, p.varGen.Current(), `; i++ {`) + p.In() + p.P(`this.`, fieldname, `[i] = byte(r.Intn(256))`) + p.Out() + p.P(`}`) + } + } else if field.IsString() { + val := fmt.Sprintf("randString%v(r)", p.localName) + if field.IsRepeated() { + p.P(p.varGen.Next(), ` := r.Intn(10)`) + p.P(`this.`, fieldname, ` = make(`, goTyp, `, `, p.varGen.Current(), `)`) + p.P(`for i := 0; i < `, p.varGen.Current(), `; i++ {`) + p.In() + p.P(`this.`, fieldname, `[i] = `, val) + p.Out() + p.P(`}`) + } else if !gogoproto.IsNullable(field) || proto3 { + p.P(`this.`, fieldname, ` = `, val) + } else { + p.P(p.varGen.Next(), `:= `, val) + p.P(`this.`, fieldname, ` = &`, p.varGen.Current()) + } + } else { + typName := generator.GoTypeToName(goTyp) + if field.IsRepeated() { + p.P(p.varGen.Next(), ` := r.Intn(100)`) + p.P(`this.`, fieldname, ` = make(`, goTyp, `, `, p.varGen.Current(), `)`) + p.P(`for i := 0; i < `, p.varGen.Current(), `; i++ {`) + p.In() + p.P(`this.`, fieldname, `[i] = `, value(typName, field.GetType())) + if negative(field.GetType()) { + p.P(`if r.Intn(2) == 0 {`) + p.In() + p.P(`this.`, fieldname, `[i] *= -1`) + p.Out() + p.P(`}`) + } + p.Out() + p.P(`}`) + } else if !gogoproto.IsNullable(field) || proto3 { + p.P(`this.`, fieldname, ` = `, value(typName, field.GetType())) + if negative(field.GetType()) { + p.P(`if r.Intn(2) == 0 {`) + p.In() + p.P(`this.`, fieldname, ` *= -1`) + p.Out() + p.P(`}`) + } + } else { + p.P(p.varGen.Next(), ` := `, value(typName, field.GetType())) + if negative(field.GetType()) { + p.P(`if r.Intn(2) == 0 {`) + p.In() + p.P(p.varGen.Current(), ` *= -1`) + p.Out() + p.P(`}`) + } + p.P(`this.`, fieldname, ` = &`, p.varGen.Current()) + } + } + } +} + +func (p *plugin) hasLoop(field *descriptor.FieldDescriptorProto, visited []*generator.Descriptor, excludes []*generator.Descriptor) *generator.Descriptor { + if field.IsMessage() || p.IsGroup(field) { + fieldMessage := p.ObjectNamed(field.GetTypeName()).(*generator.Descriptor) + fieldTypeName := generator.CamelCaseSlice(fieldMessage.TypeName()) + for _, message := range visited { + messageTypeName := generator.CamelCaseSlice(message.TypeName()) + if fieldTypeName == messageTypeName { + for _, e := range excludes { + if fieldTypeName == generator.CamelCaseSlice(e.TypeName()) { + return nil + } + } + return fieldMessage + } + } + for _, f := range fieldMessage.Field { + visited = append(visited, fieldMessage) + loopTo := p.hasLoop(f, visited, excludes) + if loopTo != nil { + return loopTo + } + } + } + return nil +} + +func (p *plugin) loops(field *descriptor.FieldDescriptorProto, message *generator.Descriptor) int { + //fmt.Fprintf(os.Stderr, "loops %v %v\n", field.GetTypeName(), generator.CamelCaseSlice(message.TypeName())) + excludes := []*generator.Descriptor{} + loops := 0 + for { + visited := []*generator.Descriptor{} + loopTo := p.hasLoop(field, visited, excludes) + if loopTo == nil { + break + } + //fmt.Fprintf(os.Stderr, "loopTo %v\n", generator.CamelCaseSlice(loopTo.TypeName())) + excludes = append(excludes, loopTo) + loops++ + } + return loops +} + +func (p *plugin) Generate(file *generator.FileDescriptor) { + p.atleastOne = false + p.PluginImports = generator.NewPluginImports(p.Generator) + p.varGen = NewVarGen() + proto3 := gogoproto.IsProto3(file.FileDescriptorProto) + + p.localName = generator.FileName(file) + protoPkg := p.NewImport("github.com/gogo/protobuf/proto") + if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) { + protoPkg = p.NewImport("github.com/golang/protobuf/proto") + } + + for _, message := range file.Messages() { + if !gogoproto.HasPopulate(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + p.atleastOne = true + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + p.P(`func NewPopulated`, ccTypeName, `(r randy`, p.localName, `, easy bool) *`, ccTypeName, ` {`) + p.In() + p.P(`this := &`, ccTypeName, `{}`) + if gogoproto.IsUnion(message.File(), message.DescriptorProto) && len(message.Field) > 0 { + loopLevels := make([]int, len(message.Field)) + maxLoopLevel := 0 + for i, field := range message.Field { + loopLevels[i] = p.loops(field, message) + if loopLevels[i] > maxLoopLevel { + maxLoopLevel = loopLevels[i] + } + } + ran := 0 + for i := range loopLevels { + ran += int(math.Pow10(maxLoopLevel - loopLevels[i])) + } + p.P(`fieldNum := r.Intn(`, fmt.Sprintf("%d", ran), `)`) + p.P(`switch fieldNum {`) + k := 0 + for i, field := range message.Field { + is := []string{} + ran := int(math.Pow10(maxLoopLevel - loopLevels[i])) + for j := 0; j < ran; j++ { + is = append(is, fmt.Sprintf("%d", j+k)) + } + k += ran + p.P(`case `, strings.Join(is, ","), `:`) + p.In() + p.GenerateField(file, message, field) + p.Out() + } + p.P(`}`) + } else { + var maxFieldNumber int32 + oneofs := make(map[string]struct{}) + for _, field := range message.Field { + if field.GetNumber() > maxFieldNumber { + maxFieldNumber = field.GetNumber() + } + oneof := field.OneofIndex != nil + if !oneof { + if field.IsRequired() || (!gogoproto.IsNullable(field) && !field.IsRepeated()) || (proto3 && !field.IsMessage()) { + p.GenerateField(file, message, field) + } else { + p.P(`if r.Intn(10) != 0 {`) + p.In() + p.GenerateField(file, message, field) + p.Out() + p.P(`}`) + } + } else { + fieldname := p.GetFieldName(message, field) + if _, ok := oneofs[fieldname]; ok { + continue + } else { + oneofs[fieldname] = struct{}{} + } + fieldNumbers := []int32{} + for _, f := range message.Field { + fname := p.GetFieldName(message, f) + if fname == fieldname { + fieldNumbers = append(fieldNumbers, f.GetNumber()) + } + } + p.P(`oneofNumber_`, fieldname, ` := `, fmt.Sprintf("%#v", fieldNumbers), `[r.Intn(`, strconv.Itoa(len(fieldNumbers)), `)]`) + p.P(`switch oneofNumber_`, fieldname, ` {`) + for _, f := range message.Field { + fname := p.GetFieldName(message, f) + if fname != fieldname { + continue + } + p.P(`case `, strconv.Itoa(int(f.GetNumber())), `:`) + p.In() + ccTypeName := p.OneOfTypeName(message, f) + p.P(`this.`, fname, ` = NewPopulated`, ccTypeName, `(r, easy)`) + p.Out() + } + p.P(`}`) + } + } + if message.DescriptorProto.HasExtension() { + p.P(`if !easy && r.Intn(10) != 0 {`) + p.In() + p.P(`l := r.Intn(5)`) + p.P(`for i := 0; i < l; i++ {`) + p.In() + if len(message.DescriptorProto.GetExtensionRange()) > 1 { + p.P(`eIndex := r.Intn(`, strconv.Itoa(len(message.DescriptorProto.GetExtensionRange())), `)`) + p.P(`fieldNumber := 0`) + p.P(`switch eIndex {`) + for i, e := range message.DescriptorProto.GetExtensionRange() { + p.P(`case `, strconv.Itoa(i), `:`) + p.In() + p.P(`fieldNumber = r.Intn(`, strconv.Itoa(int(e.GetEnd()-e.GetStart())), `) + `, strconv.Itoa(int(e.GetStart()))) + p.Out() + if e.GetEnd() > maxFieldNumber { + maxFieldNumber = e.GetEnd() + } + } + p.P(`}`) + } else { + e := message.DescriptorProto.GetExtensionRange()[0] + p.P(`fieldNumber := r.Intn(`, strconv.Itoa(int(e.GetEnd()-e.GetStart())), `) + `, strconv.Itoa(int(e.GetStart()))) + if e.GetEnd() > maxFieldNumber { + maxFieldNumber = e.GetEnd() + } + } + p.P(`wire := r.Intn(4)`) + p.P(`if wire == 3 { wire = 5 }`) + p.P(`data := randField`, p.localName, `(nil, r, fieldNumber, wire)`) + p.P(protoPkg.Use(), `.SetRawExtension(this, int32(fieldNumber), data)`) + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + } + + if maxFieldNumber < (1 << 10) { + p.P(`if !easy && r.Intn(10) != 0 {`) + p.In() + if gogoproto.HasUnrecognized(file.FileDescriptorProto, message.DescriptorProto) { + p.P(`this.XXX_unrecognized = randUnrecognized`, p.localName, `(r, `, strconv.Itoa(int(maxFieldNumber+1)), `)`) + } + p.Out() + p.P(`}`) + } + } + p.P(`return this`) + p.Out() + p.P(`}`) + p.P(``) + + //Generate NewPopulated functions for oneof fields + m := proto.Clone(message.DescriptorProto).(*descriptor.DescriptorProto) + for _, f := range m.Field { + oneof := f.OneofIndex != nil + if !oneof { + continue + } + ccTypeName := p.OneOfTypeName(message, f) + p.P(`func NewPopulated`, ccTypeName, `(r randy`, p.localName, `, easy bool) *`, ccTypeName, ` {`) + p.In() + p.P(`this := &`, ccTypeName, `{}`) + vanity.TurnOffNullableForNativeTypesWithoutDefaultsOnly(f) + p.GenerateField(file, message, f) + p.P(`return this`) + p.Out() + p.P(`}`) + } + } + + if !p.atleastOne { + return + } + + p.P(`type randy`, p.localName, ` interface {`) + p.In() + p.P(`Float32() float32`) + p.P(`Float64() float64`) + p.P(`Int63() int64`) + p.P(`Int31() int32`) + p.P(`Uint32() uint32`) + p.P(`Intn(n int) int`) + p.Out() + p.P(`}`) + + p.P(`func randUTF8Rune`, p.localName, `(r randy`, p.localName, `) rune {`) + p.In() + p.P(`ru := r.Intn(62)`) + p.P(`if ru < 10 {`) + p.In() + p.P(`return rune(ru+48)`) + p.Out() + p.P(`} else if ru < 36 {`) + p.In() + p.P(`return rune(ru+55)`) + p.Out() + p.P(`}`) + p.P(`return rune(ru+61)`) + p.Out() + p.P(`}`) + + p.P(`func randString`, p.localName, `(r randy`, p.localName, `) string {`) + p.In() + p.P(p.varGen.Next(), ` := r.Intn(100)`) + p.P(`tmps := make([]rune, `, p.varGen.Current(), `)`) + p.P(`for i := 0; i < `, p.varGen.Current(), `; i++ {`) + p.In() + p.P(`tmps[i] = randUTF8Rune`, p.localName, `(r)`) + p.Out() + p.P(`}`) + p.P(`return string(tmps)`) + p.Out() + p.P(`}`) + + p.P(`func randUnrecognized`, p.localName, `(r randy`, p.localName, `, maxFieldNumber int) (data []byte) {`) + p.In() + p.P(`l := r.Intn(5)`) + p.P(`for i := 0; i < l; i++ {`) + p.In() + p.P(`wire := r.Intn(4)`) + p.P(`if wire == 3 { wire = 5 }`) + p.P(`fieldNumber := maxFieldNumber + r.Intn(100)`) + p.P(`data = randField`, p.localName, `(data, r, fieldNumber, wire)`) + p.Out() + p.P(`}`) + p.P(`return data`) + p.Out() + p.P(`}`) + + p.P(`func randField`, p.localName, `(data []byte, r randy`, p.localName, `, fieldNumber int, wire int) []byte {`) + p.In() + p.P(`key := uint32(fieldNumber)<<3 | uint32(wire)`) + p.P(`switch wire {`) + p.P(`case 0:`) + p.In() + p.P(`data = encodeVarintPopulate`, p.localName, `(data, uint64(key))`) + p.P(p.varGen.Next(), ` := r.Int63()`) + p.P(`if r.Intn(2) == 0 {`) + p.In() + p.P(p.varGen.Current(), ` *= -1`) + p.Out() + p.P(`}`) + p.P(`data = encodeVarintPopulate`, p.localName, `(data, uint64(`, p.varGen.Current(), `))`) + p.Out() + p.P(`case 1:`) + p.In() + p.P(`data = encodeVarintPopulate`, p.localName, `(data, uint64(key))`) + p.P(`data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))`) + p.Out() + p.P(`case 2:`) + p.In() + p.P(`data = encodeVarintPopulate`, p.localName, `(data, uint64(key))`) + p.P(`ll := r.Intn(100)`) + p.P(`data = encodeVarintPopulate`, p.localName, `(data, uint64(ll))`) + p.P(`for j := 0; j < ll; j++ {`) + p.In() + p.P(`data = append(data, byte(r.Intn(256)))`) + p.Out() + p.P(`}`) + p.Out() + p.P(`default:`) + p.In() + p.P(`data = encodeVarintPopulate`, p.localName, `(data, uint64(key))`) + p.P(`data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))`) + p.Out() + p.P(`}`) + p.P(`return data`) + p.Out() + p.P(`}`) + + p.P(`func encodeVarintPopulate`, p.localName, `(data []byte, v uint64) []byte {`) + p.In() + p.P(`for v >= 1<<7 {`) + p.In() + p.P(`data = append(data, uint8(uint64(v)&0x7f|0x80))`) + p.P(`v >>= 7`) + p.Out() + p.P(`}`) + p.P(`data = append(data, uint8(v))`) + p.P(`return data`) + p.Out() + p.P(`}`) + +} + +func init() { + generator.RegisterPlugin(NewPlugin()) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/size/size.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/size/size.go new file mode 100644 index 0000000000000000000000000000000000000000..b15d045e01cd7d8fec90f918bdde3bd71666dcc9 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/size/size.go @@ -0,0 +1,575 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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. + +/* +The size plugin generates a Size method for each message. +This is useful with the MarshalTo method generated by the marshalto plugin and the +gogoproto.marshaler and gogoproto.marshaler_all extensions. + +It is enabled by the following extensions: + + - sizer + - sizer_all + +The size plugin also generates a test given it is enabled using one of the following extensions: + + - testgen + - testgen_all + +And a benchmark given it is enabled using one of the following extensions: + + - benchgen + - benchgen_all + +Let us look at: + + github.com/gogo/protobuf/test/example/example.proto + +Btw all the output can be seen at: + + github.com/gogo/protobuf/test/example/* + +The following message: + + option (gogoproto.sizer_all) = true; + + message B { + option (gogoproto.description) = true; + optional A A = 1 [(gogoproto.nullable) = false, (gogoproto.embed) = true]; + repeated bytes G = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; + } + +given to the size plugin, will generate the following code: + + func (m *B) Size() (n int) { + var l int + _ = l + l = m.A.Size() + n += 1 + l + sovExample(uint64(l)) + if len(m.G) > 0 { + for _, e := range m.G { + l = e.Size() + n += 1 + l + sovExample(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n + } + +and the following test code: + + func TestBSize(t *testing5.T) { + popr := math_rand5.New(math_rand5.NewSource(time5.Now().UnixNano())) + p := NewPopulatedB(popr, true) + data, err := github_com_gogo_protobuf_proto2.Marshal(p) + if err != nil { + panic(err) + } + size := p.Size() + if len(data) != size { + t.Fatalf("size %v != marshalled size %v", size, len(data)) + } + } + + func BenchmarkBSize(b *testing5.B) { + popr := math_rand5.New(math_rand5.NewSource(616)) + total := 0 + pops := make([]*B, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedB(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) + } + +The sovExample function is a size of varint function for the example.pb.go file. + +*/ +package size + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + descriptor "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity" + "fmt" + "strconv" + "strings" +) + +type size struct { + *generator.Generator + generator.PluginImports + atleastOne bool + localName string +} + +func NewSize() *size { + return &size{} +} + +func (p *size) Name() string { + return "size" +} + +func (p *size) Init(g *generator.Generator) { + p.Generator = g +} + +func wireToType(wire string) int { + switch wire { + case "fixed64": + return proto.WireFixed64 + case "fixed32": + return proto.WireFixed32 + case "varint": + return proto.WireVarint + case "bytes": + return proto.WireBytes + case "group": + return proto.WireBytes + case "zigzag32": + return proto.WireVarint + case "zigzag64": + return proto.WireVarint + } + panic("unreachable") +} + +func keySize(fieldNumber int32, wireType int) int { + x := uint32(fieldNumber)<<3 | uint32(wireType) + size := 0 + for size = 0; x > 127; size++ { + x >>= 7 + } + size++ + return size +} + +func (p *size) sizeVarint() { + p.P(` + func sov`, p.localName, `(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n + }`) +} + +func (p *size) sizeZigZag() { + p.P(`func soz`, p.localName, `(x uint64) (n int) { + return sov`, p.localName, `(uint64((x << 1) ^ uint64((int64(x) >> 63)))) + }`) +} + +func (p *size) generateField(proto3 bool, file *generator.FileDescriptor, message *generator.Descriptor, field *descriptor.FieldDescriptorProto) { + fieldname := p.GetOneOfFieldName(message, field) + nullable := gogoproto.IsNullable(field) + repeated := field.IsRepeated() + if repeated { + p.P(`if len(m.`, fieldname, `) > 0 {`) + p.In() + } else if ((!proto3 || field.IsMessage()) && nullable) || (!gogoproto.IsCustomType(field) && *field.Type == descriptor.FieldDescriptorProto_TYPE_BYTES) { + p.P(`if m.`, fieldname, ` != nil {`) + p.In() + } + packed := field.IsPacked() + _, wire := p.GoType(message, field) + wireType := wireToType(wire) + fieldNumber := field.GetNumber() + if packed { + wireType = proto.WireBytes + } + key := keySize(fieldNumber, wireType) + switch *field.Type { + case descriptor.FieldDescriptorProto_TYPE_DOUBLE, + descriptor.FieldDescriptorProto_TYPE_FIXED64, + descriptor.FieldDescriptorProto_TYPE_SFIXED64: + if packed { + p.P(`n+=`, strconv.Itoa(key), `+sov`, p.localName, `(uint64(len(m.`, fieldname, `)*8))`, `+len(m.`, fieldname, `)*8`) + } else if repeated { + p.P(`n+=`, strconv.Itoa(key+8), `*len(m.`, fieldname, `)`) + } else if proto3 { + p.P(`if m.`, fieldname, ` != 0 {`) + p.In() + p.P(`n+=`, strconv.Itoa(key+8)) + p.Out() + p.P(`}`) + } else if nullable { + p.P(`n+=`, strconv.Itoa(key+8)) + } else { + p.P(`n+=`, strconv.Itoa(key+8)) + } + case descriptor.FieldDescriptorProto_TYPE_FLOAT, + descriptor.FieldDescriptorProto_TYPE_FIXED32, + descriptor.FieldDescriptorProto_TYPE_SFIXED32: + if packed { + p.P(`n+=`, strconv.Itoa(key), `+sov`, p.localName, `(uint64(len(m.`, fieldname, `)*4))`, `+len(m.`, fieldname, `)*4`) + } else if repeated { + p.P(`n+=`, strconv.Itoa(key+4), `*len(m.`, fieldname, `)`) + } else if proto3 { + p.P(`if m.`, fieldname, ` != 0 {`) + p.In() + p.P(`n+=`, strconv.Itoa(key+4)) + p.Out() + p.P(`}`) + } else if nullable { + p.P(`n+=`, strconv.Itoa(key+4)) + } else { + p.P(`n+=`, strconv.Itoa(key+4)) + } + case descriptor.FieldDescriptorProto_TYPE_INT64, + descriptor.FieldDescriptorProto_TYPE_UINT64, + descriptor.FieldDescriptorProto_TYPE_UINT32, + descriptor.FieldDescriptorProto_TYPE_ENUM, + descriptor.FieldDescriptorProto_TYPE_INT32: + if packed { + p.P(`l = 0`) + p.P(`for _, e := range m.`, fieldname, ` {`) + p.In() + p.P(`l+=sov`, p.localName, `(uint64(e))`) + p.Out() + p.P(`}`) + p.P(`n+=`, strconv.Itoa(key), `+sov`, p.localName, `(uint64(l))+l`) + } else if repeated { + p.P(`for _, e := range m.`, fieldname, ` {`) + p.In() + p.P(`n+=`, strconv.Itoa(key), `+sov`, p.localName, `(uint64(e))`) + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`if m.`, fieldname, ` != 0 {`) + p.In() + p.P(`n+=`, strconv.Itoa(key), `+sov`, p.localName, `(uint64(m.`, fieldname, `))`) + p.Out() + p.P(`}`) + } else if nullable { + p.P(`n+=`, strconv.Itoa(key), `+sov`, p.localName, `(uint64(*m.`, fieldname, `))`) + } else { + p.P(`n+=`, strconv.Itoa(key), `+sov`, p.localName, `(uint64(m.`, fieldname, `))`) + } + case descriptor.FieldDescriptorProto_TYPE_BOOL: + if packed { + p.P(`n+=`, strconv.Itoa(key), `+sov`, p.localName, `(uint64(len(m.`, fieldname, `)))`, `+len(m.`, fieldname, `)*1`) + } else if repeated { + p.P(`n+=`, strconv.Itoa(key+1), `*len(m.`, fieldname, `)`) + } else if proto3 { + p.P(`if m.`, fieldname, ` {`) + p.In() + p.P(`n+=`, strconv.Itoa(key+1)) + p.Out() + p.P(`}`) + } else if nullable { + p.P(`n+=`, strconv.Itoa(key+1)) + } else { + p.P(`n+=`, strconv.Itoa(key+1)) + } + case descriptor.FieldDescriptorProto_TYPE_STRING: + if repeated { + p.P(`for _, s := range m.`, fieldname, ` { `) + p.In() + p.P(`l = len(s)`) + p.P(`n+=`, strconv.Itoa(key), `+l+sov`, p.localName, `(uint64(l))`) + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`l=len(m.`, fieldname, `)`) + p.P(`if l > 0 {`) + p.In() + p.P(`n+=`, strconv.Itoa(key), `+l+sov`, p.localName, `(uint64(l))`) + p.Out() + p.P(`}`) + } else if nullable { + p.P(`l=len(*m.`, fieldname, `)`) + p.P(`n+=`, strconv.Itoa(key), `+l+sov`, p.localName, `(uint64(l))`) + } else { + p.P(`l=len(m.`, fieldname, `)`) + p.P(`n+=`, strconv.Itoa(key), `+l+sov`, p.localName, `(uint64(l))`) + } + case descriptor.FieldDescriptorProto_TYPE_GROUP: + panic(fmt.Errorf("size does not support group %v", fieldname)) + case descriptor.FieldDescriptorProto_TYPE_MESSAGE: + if generator.IsMap(file.FileDescriptorProto, field) { + mapMsg := generator.GetMap(file.FileDescriptorProto, field) + keyField, valueField := mapMsg.GetMapFields() + _, keywire := p.GoType(nil, keyField) + _, valuewire := p.GoType(nil, valueField) + _, fieldwire := p.GoType(nil, field) + fieldKeySize := keySize(field.GetNumber(), wireToType(fieldwire)) + keyKeySize := keySize(1, wireToType(keywire)) + valueKeySize := keySize(2, wireToType(valuewire)) + p.P(`for k, v := range m.`, fieldname, ` { `) + p.In() + p.P(`_ = k`) + p.P(`_ = v`) + sum := []string{strconv.Itoa(keyKeySize)} + switch keyField.GetType() { + case descriptor.FieldDescriptorProto_TYPE_DOUBLE, + descriptor.FieldDescriptorProto_TYPE_FIXED64, + descriptor.FieldDescriptorProto_TYPE_SFIXED64: + sum = append(sum, `8`) + case descriptor.FieldDescriptorProto_TYPE_FLOAT, + descriptor.FieldDescriptorProto_TYPE_FIXED32, + descriptor.FieldDescriptorProto_TYPE_SFIXED32: + sum = append(sum, `4`) + case descriptor.FieldDescriptorProto_TYPE_INT64, + descriptor.FieldDescriptorProto_TYPE_UINT64, + descriptor.FieldDescriptorProto_TYPE_UINT32, + descriptor.FieldDescriptorProto_TYPE_ENUM, + descriptor.FieldDescriptorProto_TYPE_INT32: + sum = append(sum, `sov`+p.localName+`(uint64(k))`) + case descriptor.FieldDescriptorProto_TYPE_BOOL: + sum = append(sum, `1`) + case descriptor.FieldDescriptorProto_TYPE_STRING, + descriptor.FieldDescriptorProto_TYPE_BYTES: + sum = append(sum, `len(k)+sov`+p.localName+`(uint64(len(k)))`) + case descriptor.FieldDescriptorProto_TYPE_SINT32, + descriptor.FieldDescriptorProto_TYPE_SINT64: + sum = append(sum, `soz`+p.localName+`(uint64(k))`) + } + sum = append(sum, strconv.Itoa(valueKeySize)) + switch valueField.GetType() { + case descriptor.FieldDescriptorProto_TYPE_DOUBLE, + descriptor.FieldDescriptorProto_TYPE_FIXED64, + descriptor.FieldDescriptorProto_TYPE_SFIXED64: + sum = append(sum, strconv.Itoa(8)) + case descriptor.FieldDescriptorProto_TYPE_FLOAT, + descriptor.FieldDescriptorProto_TYPE_FIXED32, + descriptor.FieldDescriptorProto_TYPE_SFIXED32: + sum = append(sum, strconv.Itoa(4)) + case descriptor.FieldDescriptorProto_TYPE_INT64, + descriptor.FieldDescriptorProto_TYPE_UINT64, + descriptor.FieldDescriptorProto_TYPE_UINT32, + descriptor.FieldDescriptorProto_TYPE_ENUM, + descriptor.FieldDescriptorProto_TYPE_INT32: + sum = append(sum, `sov`+p.localName+`(uint64(v))`) + case descriptor.FieldDescriptorProto_TYPE_BOOL: + sum = append(sum, `1`) + case descriptor.FieldDescriptorProto_TYPE_STRING, + descriptor.FieldDescriptorProto_TYPE_BYTES: + sum = append(sum, `len(v)+sov`+p.localName+`(uint64(len(v)))`) + case descriptor.FieldDescriptorProto_TYPE_SINT32, + descriptor.FieldDescriptorProto_TYPE_SINT64: + sum = append(sum, `soz`+p.localName+`(uint64(v))`) + case descriptor.FieldDescriptorProto_TYPE_MESSAGE: + p.P(`l = 0`) + p.P(`if v != nil {`) + p.In() + p.P(`l= v.Size()`) + p.Out() + p.P(`}`) + sum = append(sum, `l+sov`+p.localName+`(uint64(l))`) + } + p.P(`mapEntrySize := `, strings.Join(sum, "+")) + p.P(`n+=mapEntrySize+`, fieldKeySize, `+sov`, p.localName, `(uint64(mapEntrySize))`) + p.Out() + p.P(`}`) + } else if repeated { + p.P(`for _, e := range m.`, fieldname, ` { `) + p.In() + p.P(`l=e.Size()`) + p.P(`n+=`, strconv.Itoa(key), `+l+sov`, p.localName, `(uint64(l))`) + p.Out() + p.P(`}`) + } else { + p.P(`l=m.`, fieldname, `.Size()`) + p.P(`n+=`, strconv.Itoa(key), `+l+sov`, p.localName, `(uint64(l))`) + } + case descriptor.FieldDescriptorProto_TYPE_BYTES: + if !gogoproto.IsCustomType(field) { + if repeated { + p.P(`for _, b := range m.`, fieldname, ` { `) + p.In() + p.P(`l = len(b)`) + p.P(`n+=`, strconv.Itoa(key), `+l+sov`, p.localName, `(uint64(l))`) + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`l=len(m.`, fieldname, `)`) + p.P(`if l > 0 {`) + p.In() + p.P(`n+=`, strconv.Itoa(key), `+l+sov`, p.localName, `(uint64(l))`) + p.Out() + p.P(`}`) + } else { + p.P(`l=len(m.`, fieldname, `)`) + p.P(`n+=`, strconv.Itoa(key), `+l+sov`, p.localName, `(uint64(l))`) + } + } else { + if repeated { + p.P(`for _, e := range m.`, fieldname, ` { `) + p.In() + p.P(`l=e.Size()`) + p.P(`n+=`, strconv.Itoa(key), `+l+sov`, p.localName, `(uint64(l))`) + p.Out() + p.P(`}`) + } else { + p.P(`l=m.`, fieldname, `.Size()`) + p.P(`n+=`, strconv.Itoa(key), `+l+sov`, p.localName, `(uint64(l))`) + } + } + case descriptor.FieldDescriptorProto_TYPE_SINT32, + descriptor.FieldDescriptorProto_TYPE_SINT64: + if packed { + p.P(`l = 0`) + p.P(`for _, e := range m.`, fieldname, ` {`) + p.In() + p.P(`l+=soz`, p.localName, `(uint64(e))`) + p.Out() + p.P(`}`) + p.P(`n+=`, strconv.Itoa(key), `+sov`, p.localName, `(uint64(l))+l`) + } else if repeated { + p.P(`for _, e := range m.`, fieldname, ` {`) + p.In() + p.P(`n+=`, strconv.Itoa(key), `+soz`, p.localName, `(uint64(e))`) + p.Out() + p.P(`}`) + } else if proto3 { + p.P(`if m.`, fieldname, ` != 0 {`) + p.In() + p.P(`n+=`, strconv.Itoa(key), `+soz`, p.localName, `(uint64(m.`, fieldname, `))`) + p.Out() + p.P(`}`) + } else if nullable { + p.P(`n+=`, strconv.Itoa(key), `+soz`, p.localName, `(uint64(*m.`, fieldname, `))`) + } else { + p.P(`n+=`, strconv.Itoa(key), `+soz`, p.localName, `(uint64(m.`, fieldname, `))`) + } + default: + panic("not implemented") + } + if ((!proto3 || field.IsMessage()) && nullable) || repeated || (!gogoproto.IsCustomType(field) && *field.Type == descriptor.FieldDescriptorProto_TYPE_BYTES) { + p.Out() + p.P(`}`) + } +} + +func (p *size) Generate(file *generator.FileDescriptor) { + p.PluginImports = generator.NewPluginImports(p.Generator) + p.atleastOne = false + p.localName = generator.FileName(file) + protoPkg := p.NewImport("github.com/gogo/protobuf/proto") + if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) { + protoPkg = p.NewImport("github.com/golang/protobuf/proto") + } + for _, message := range file.Messages() { + if !gogoproto.IsSizer(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + p.atleastOne = true + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + p.P(`func (m *`, ccTypeName, `) Size() (n int) {`) + p.In() + p.P(`var l int`) + p.P(`_ = l`) + oneofs := make(map[string]struct{}) + for _, field := range message.Field { + oneof := field.OneofIndex != nil + if !oneof { + proto3 := gogoproto.IsProto3(file.FileDescriptorProto) + p.generateField(proto3, file, message, field) + } else { + fieldname := p.GetFieldName(message, field) + if _, ok := oneofs[fieldname]; ok { + continue + } else { + oneofs[fieldname] = struct{}{} + } + p.P(`if m.`, fieldname, ` != nil {`) + p.In() + p.P(`n+=m.`, fieldname, `.Size()`) + p.Out() + p.P(`}`) + } + } + if message.DescriptorProto.HasExtension() { + p.P(`if m.XXX_extensions != nil {`) + p.In() + if gogoproto.HasExtensionsMap(file.FileDescriptorProto, message.DescriptorProto) { + p.P(`n += `, protoPkg.Use(), `.SizeOfExtensionMap(m.XXX_extensions)`) + } else { + p.P(`n+=len(m.XXX_extensions)`) + } + p.Out() + p.P(`}`) + } + if gogoproto.HasUnrecognized(file.FileDescriptorProto, message.DescriptorProto) { + p.P(`if m.XXX_unrecognized != nil {`) + p.In() + p.P(`n+=len(m.XXX_unrecognized)`) + p.Out() + p.P(`}`) + } + p.P(`return n`) + p.Out() + p.P(`}`) + p.P() + + //Generate Size methods for oneof fields + m := proto.Clone(message.DescriptorProto).(*descriptor.DescriptorProto) + for _, f := range m.Field { + oneof := f.OneofIndex != nil + if !oneof { + continue + } + ccTypeName := p.OneOfTypeName(message, f) + p.P(`func (m *`, ccTypeName, `) Size() (n int) {`) + p.In() + p.P(`var l int`) + p.P(`_ = l`) + vanity.TurnOffNullableForNativeTypesWithoutDefaultsOnly(f) + p.generateField(false, file, message, f) + p.P(`return n`) + p.Out() + p.P(`}`) + } + } + + if !p.atleastOne { + return + } + + p.sizeVarint() + p.sizeZigZag() + +} + +func init() { + generator.RegisterPlugin(NewSize()) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/size/sizetest.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/size/sizetest.go new file mode 100644 index 0000000000000000000000000000000000000000..5e8387d3fb68bf7037a7b4b7010e256b60b7e7ff --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/size/sizetest.go @@ -0,0 +1,127 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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 size + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/testgen" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" +) + +type test struct { + *generator.Generator +} + +func NewTest(g *generator.Generator) testgen.TestPlugin { + return &test{g} +} + +func (p *test) Generate(imports generator.PluginImports, file *generator.FileDescriptor) bool { + used := false + randPkg := imports.NewImport("math/rand") + timePkg := imports.NewImport("time") + testingPkg := imports.NewImport("testing") + protoPkg := imports.NewImport("github.com/gogo/protobuf/proto") + if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) { + protoPkg = imports.NewImport("github.com/golang/protobuf/proto") + } + for _, message := range file.Messages() { + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + if !gogoproto.IsSizer(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + + if gogoproto.HasTestGen(file.FileDescriptorProto, message.DescriptorProto) { + used = true + p.P(`func Test`, ccTypeName, `Size(t *`, testingPkg.Use(), `.T) {`) + p.In() + p.P(`seed := `, timePkg.Use(), `.Now().UnixNano()`) + p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(seed))`) + p.P(`p := NewPopulated`, ccTypeName, `(popr, true)`) + p.P(`size2 := `, protoPkg.Use(), `.Size(p)`) + p.P(`data, err := `, protoPkg.Use(), `.Marshal(p)`) + p.P(`if err != nil {`) + p.In() + p.P(`t.Fatalf("seed = %d, err = %v", seed, err)`) + p.Out() + p.P(`}`) + p.P(`size := p.Size()`) + p.P(`if len(data) != size {`) + p.In() + p.P(`t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data))`) + p.Out() + p.P(`}`) + p.P(`if size2 != size {`) + p.In() + p.P(`t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2)`) + p.Out() + p.P(`}`) + p.P(`size3 := `, protoPkg.Use(), `.Size(p)`) + p.P(`if size3 != size {`) + p.In() + p.P(`t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3)`) + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + p.P() + } + + if gogoproto.HasBenchGen(file.FileDescriptorProto, message.DescriptorProto) { + used = true + p.P(`func Benchmark`, ccTypeName, `Size(b *`, testingPkg.Use(), `.B) {`) + p.In() + p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(616))`) + p.P(`total := 0`) + p.P(`pops := make([]*`, ccTypeName, `, 1000)`) + p.P(`for i := 0; i < 1000; i++ {`) + p.In() + p.P(`pops[i] = NewPopulated`, ccTypeName, `(popr, false)`) + p.Out() + p.P(`}`) + p.P(`b.ResetTimer()`) + p.P(`for i := 0; i < b.N; i++ {`) + p.In() + p.P(`total += pops[i%1000].Size()`) + p.Out() + p.P(`}`) + p.P(`b.SetBytes(int64(total / b.N))`) + p.Out() + p.P(`}`) + p.P() + } + + } + return used +} + +func init() { + testgen.RegisterTestPlugin(NewTest) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/stringer/stringer.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/stringer/stringer.go new file mode 100644 index 0000000000000000000000000000000000000000..14df573f57db17da546afe7b5d3e3863a79d4651 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/stringer/stringer.go @@ -0,0 +1,283 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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. + +/* +The stringer plugin generates a String method for each message. + +It is enabled by the following extensions: + + - stringer + - stringer_all + +The stringer plugin also generates a test given it is enabled using one of the following extensions: + + - testgen + - testgen_all + +Let us look at: + + github.com/gogo/protobuf/test/example/example.proto + +Btw all the output can be seen at: + + github.com/gogo/protobuf/test/example/* + +The following message: + + option (gogoproto.goproto_stringer_all) = false; + option (gogoproto.stringer_all) = true; + + message A { + optional string Description = 1 [(gogoproto.nullable) = false]; + optional int64 Number = 2 [(gogoproto.nullable) = false]; + optional bytes Id = 3 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uuid", (gogoproto.nullable) = false]; + } + +given to the stringer stringer, will generate the following code: + + func (this *A) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&A{`, + `Description:` + fmt.Sprintf("%v", this.Description) + `,`, + `Number:` + fmt.Sprintf("%v", this.Number) + `,`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s + } + +and the following test code: + + func TestAStringer(t *testing4.T) { + popr := math_rand4.New(math_rand4.NewSource(time4.Now().UnixNano())) + p := NewPopulatedA(popr, false) + s1 := p.String() + s2 := fmt1.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } + } + +Typically fmt.Printf("%v") will stop to print when it reaches a pointer and +not print their values, while the generated String method will always print all values, recursively. + +*/ +package stringer + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" + "strings" +) + +type stringer struct { + *generator.Generator + generator.PluginImports + atleastOne bool + localName string +} + +func NewStringer() *stringer { + return &stringer{} +} + +func (p *stringer) Name() string { + return "stringer" +} + +func (p *stringer) Init(g *generator.Generator) { + p.Generator = g +} + +func (p *stringer) Generate(file *generator.FileDescriptor) { + proto3 := gogoproto.IsProto3(file.FileDescriptorProto) + p.PluginImports = generator.NewPluginImports(p.Generator) + p.atleastOne = false + + p.localName = generator.FileName(file) + + fmtPkg := p.NewImport("fmt") + stringsPkg := p.NewImport("strings") + reflectPkg := p.NewImport("reflect") + sortKeysPkg := p.NewImport("github.com/gogo/protobuf/sortkeys") + for _, message := range file.Messages() { + if !gogoproto.IsStringer(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if gogoproto.EnabledGoStringer(file.FileDescriptorProto, message.DescriptorProto) { + panic("old string method needs to be disabled, please use gogoproto.goproto_stringer or gogoproto.goproto_stringer_all and set it to false") + } + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + p.atleastOne = true + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + p.P(`func (this *`, ccTypeName, `) String() string {`) + p.In() + p.P(`if this == nil {`) + p.In() + p.P(`return "nil"`) + p.Out() + p.P(`}`) + for _, field := range message.Field { + if !generator.IsMap(file.FileDescriptorProto, field) { + continue + } + fieldname := p.GetFieldName(message, field) + mapMsg := generator.GetMap(file.FileDescriptorProto, field) + keyField, valueField := mapMsg.GetMapFields() + keysName := `keysFor` + fieldname + keygoTyp, _ := p.GoType(nil, keyField) + keygoTyp = strings.Replace(keygoTyp, "*", "", 1) + keyCapTyp := generator.CamelCase(keygoTyp) + valuegoTyp, _ := p.GoType(nil, valueField) + p.P(keysName, ` := make([]`, keygoTyp, `, 0, len(this.`, fieldname, `))`) + p.P(`for k, _ := range this.`, fieldname, ` {`) + p.In() + p.P(keysName, ` = append(`, keysName, `, k)`) + p.Out() + p.P(`}`) + p.P(sortKeysPkg.Use(), `.`, keyCapTyp, `s(`, keysName, `)`) + mapName := `mapStringFor` + fieldname + p.P(mapName, ` := "map[`, keygoTyp, `]`, valuegoTyp, `{"`) + p.P(`for _, k := range `, keysName, ` {`) + p.In() + p.P(mapName, ` += fmt.Sprintf("%v: %v,", k, this.`, fieldname, `[k])`) + p.Out() + p.P(`}`) + p.P(mapName, ` += "}"`) + } + p.P("s := ", stringsPkg.Use(), ".Join([]string{`&", ccTypeName, "{`,") + oneofs := make(map[string]struct{}) + for _, field := range message.Field { + nullable := gogoproto.IsNullable(field) + repeated := field.IsRepeated() + fieldname := p.GetFieldName(message, field) + oneof := field.OneofIndex != nil + if oneof { + if _, ok := oneofs[fieldname]; ok { + continue + } else { + oneofs[fieldname] = struct{}{} + } + p.P("`", fieldname, ":`", ` + `, fmtPkg.Use(), `.Sprintf("%v", this.`, fieldname, ") + `,", "`,") + } else if generator.IsMap(file.FileDescriptorProto, field) { + mapName := `mapStringFor` + fieldname + p.P("`", fieldname, ":`", ` + `, mapName, " + `,", "`,") + } else if field.IsMessage() || p.IsGroup(field) { + desc := p.ObjectNamed(field.GetTypeName()) + msgname := p.TypeName(desc) + msgnames := strings.Split(msgname, ".") + typeName := msgnames[len(msgnames)-1] + if nullable { + p.P("`", fieldname, ":`", ` + `, stringsPkg.Use(), `.Replace(`, fmtPkg.Use(), `.Sprintf("%v", this.`, fieldname, `), "`, typeName, `","`, msgname, `"`, ", 1) + `,", "`,") + } else if repeated { + p.P("`", fieldname, ":`", ` + `, stringsPkg.Use(), `.Replace(`, stringsPkg.Use(), `.Replace(`, fmtPkg.Use(), `.Sprintf("%v", this.`, fieldname, `), "`, typeName, `","`, msgname, `"`, ", 1),`&`,``,1) + `,", "`,") + } else { + p.P("`", fieldname, ":`", ` + `, stringsPkg.Use(), `.Replace(`, stringsPkg.Use(), `.Replace(this.`, fieldname, `.String(), "`, typeName, `","`, msgname, `"`, ", 1),`&`,``,1) + `,", "`,") + } + } else { + if nullable && !repeated && !proto3 { + p.P("`", fieldname, ":`", ` + valueToString`, p.localName, `(this.`, fieldname, ") + `,", "`,") + } else { + p.P("`", fieldname, ":`", ` + `, fmtPkg.Use(), `.Sprintf("%v", this.`, fieldname, ") + `,", "`,") + } + } + } + if message.DescriptorProto.HasExtension() { + if gogoproto.HasExtensionsMap(file.FileDescriptorProto, message.DescriptorProto) { + p.P("`XXX_extensions:` + proto.StringFromExtensionsMap(this.XXX_extensions) + `,`,") + } else { + p.P("`XXX_extensions:` + proto.StringFromExtensionsBytes(this.XXX_extensions) + `,`,") + } + } + if gogoproto.HasUnrecognized(file.FileDescriptorProto, message.DescriptorProto) { + p.P("`XXX_unrecognized:` + ", fmtPkg.Use(), `.Sprintf("%v", this.XXX_unrecognized) + `, "`,`,") + } + p.P("`}`,") + p.P(`}`, `,""`, ")") + p.P(`return s`) + p.Out() + p.P(`}`) + + //Generate String methods for oneof fields + for _, field := range message.Field { + oneof := field.OneofIndex != nil + if !oneof { + continue + } + ccTypeName := p.OneOfTypeName(message, field) + p.P(`func (this *`, ccTypeName, `) String() string {`) + p.In() + p.P(`if this == nil {`) + p.In() + p.P(`return "nil"`) + p.Out() + p.P(`}`) + p.P("s := ", stringsPkg.Use(), ".Join([]string{`&", ccTypeName, "{`,") + fieldname := p.GetOneOfFieldName(message, field) + if field.IsMessage() || p.IsGroup(field) { + desc := p.ObjectNamed(field.GetTypeName()) + msgname := p.TypeName(desc) + msgnames := strings.Split(msgname, ".") + typeName := msgnames[len(msgnames)-1] + p.P("`", fieldname, ":`", ` + `, stringsPkg.Use(), `.Replace(`, fmtPkg.Use(), `.Sprintf("%v", this.`, fieldname, `), "`, typeName, `","`, msgname, `"`, ", 1) + `,", "`,") + } else { + p.P("`", fieldname, ":`", ` + `, fmtPkg.Use(), `.Sprintf("%v", this.`, fieldname, ") + `,", "`,") + } + p.P("`}`,") + p.P(`}`, `,""`, ")") + p.P(`return s`) + p.Out() + p.P(`}`) + } + } + + if !p.atleastOne { + return + } + + p.P(`func valueToString`, p.localName, `(v interface{}) string {`) + p.In() + p.P(`rv := `, reflectPkg.Use(), `.ValueOf(v)`) + p.P(`if rv.IsNil() {`) + p.In() + p.P(`return "nil"`) + p.Out() + p.P(`}`) + p.P(`pv := `, reflectPkg.Use(), `.Indirect(rv).Interface()`) + p.P(`return `, fmtPkg.Use(), `.Sprintf("*%v", pv)`) + p.Out() + p.P(`}`) + +} + +func init() { + generator.RegisterPlugin(NewStringer()) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/stringer/stringertest.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/stringer/stringertest.go new file mode 100644 index 0000000000000000000000000000000000000000..88df3a9e5416cc120c20e854c902e40463d1dedb --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/stringer/stringertest.go @@ -0,0 +1,81 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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 stringer + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/testgen" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" +) + +type test struct { + *generator.Generator +} + +func NewTest(g *generator.Generator) testgen.TestPlugin { + return &test{g} +} + +func (p *test) Generate(imports generator.PluginImports, file *generator.FileDescriptor) bool { + used := false + randPkg := imports.NewImport("math/rand") + timePkg := imports.NewImport("time") + testingPkg := imports.NewImport("testing") + fmtPkg := imports.NewImport("fmt") + for _, message := range file.Messages() { + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + if !gogoproto.IsStringer(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + + if gogoproto.HasTestGen(file.FileDescriptorProto, message.DescriptorProto) { + used = true + p.P(`func Test`, ccTypeName, `Stringer(t *`, testingPkg.Use(), `.T) {`) + p.In() + p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(`, timePkg.Use(), `.Now().UnixNano()))`) + p.P(`p := NewPopulated`, ccTypeName, `(popr, false)`) + p.P(`s1 := p.String()`) + p.P(`s2 := `, fmtPkg.Use(), `.Sprintf("%v", p)`) + p.P(`if s1 != s2 {`) + p.In() + p.P(`t.Fatalf("String want %v got %v", s1, s2)`) + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + } + + } + return used +} + +func init() { + testgen.RegisterTestPlugin(NewTest) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/testgen/testgen.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/testgen/testgen.go new file mode 100644 index 0000000000000000000000000000000000000000..4fedffd970071da508553f2a697db04c14f21e20 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/testgen/testgen.go @@ -0,0 +1,602 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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. + +/* +The testgen plugin generates Test and Benchmark functions for each message. + +Tests are enabled using the following extensions: + + - testgen + - testgen_all + +Benchmarks are enabled using the following extensions: + + - benchgen + - benchgen_all + +Let us look at: + + github.com/gogo/protobuf/test/example/example.proto + +Btw all the output can be seen at: + + github.com/gogo/protobuf/test/example/* + +The following message: + + option (gogoproto.testgen_all) = true; + option (gogoproto.benchgen_all) = true; + + message A { + optional string Description = 1 [(gogoproto.nullable) = false]; + optional int64 Number = 2 [(gogoproto.nullable) = false]; + optional bytes Id = 3 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uuid", (gogoproto.nullable) = false]; + } + +given to the testgen plugin, will generate the following test code: + + func TestAProto(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedA(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &A{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("%#v !Proto %#v", msg, p) + } + } + + func BenchmarkAProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*A, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedA(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) + } + + func BenchmarkAProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedA(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &A{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) + } + + + func TestAJSON(t *testing1.T) { + popr := math_rand1.New(math_rand1.NewSource(time1.Now().UnixNano())) + p := NewPopulatedA(popr, true) + jsondata, err := encoding_json.Marshal(p) + if err != nil { + panic(err) + } + msg := &A{} + err = encoding_json.Unmarshal(jsondata, msg) + if err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("%#v !Json Equal %#v", msg, p) + } + } + + func TestAProtoText(t *testing2.T) { + popr := math_rand2.New(math_rand2.NewSource(time2.Now().UnixNano())) + p := NewPopulatedA(popr, true) + data := github_com_gogo_protobuf_proto1.MarshalTextString(p) + msg := &A{} + if err := github_com_gogo_protobuf_proto1.UnmarshalText(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("%#v !Proto %#v", msg, p) + } + } + + func TestAProtoCompactText(t *testing2.T) { + popr := math_rand2.New(math_rand2.NewSource(time2.Now().UnixNano())) + p := NewPopulatedA(popr, true) + data := github_com_gogo_protobuf_proto1.CompactTextString(p) + msg := &A{} + if err := github_com_gogo_protobuf_proto1.UnmarshalText(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseProto %#v, since %v", msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("%#v !Proto %#v", msg, p) + } + } + +Other registered tests are also generated. +Tests are registered to this test plugin by calling the following function. + + func RegisterTestPlugin(newFunc NewTestPlugin) + +where NewTestPlugin is: + + type NewTestPlugin func(g *generator.Generator) TestPlugin + +and TestPlugin is an interface: + + type TestPlugin interface { + Generate(imports generator.PluginImports, file *generator.FileDescriptor) (used bool) + } + +Plugins that use this interface include: + + - populate + - gostring + - equal + - union + - and more + +Please look at these plugins as examples of how to create your own. +A good idea is to let each plugin generate its own tests. + +*/ +package testgen + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" +) + +type TestPlugin interface { + Generate(imports generator.PluginImports, file *generator.FileDescriptor) (used bool) +} + +type NewTestPlugin func(g *generator.Generator) TestPlugin + +var testplugins = make([]NewTestPlugin, 0) + +func RegisterTestPlugin(newFunc NewTestPlugin) { + testplugins = append(testplugins, newFunc) +} + +type plugin struct { + *generator.Generator + generator.PluginImports + tests []TestPlugin +} + +func NewPlugin() *plugin { + return &plugin{} +} + +func (p *plugin) Name() string { + return "testgen" +} + +func (p *plugin) Init(g *generator.Generator) { + p.Generator = g + p.tests = make([]TestPlugin, 0, len(testplugins)) + for i := range testplugins { + p.tests = append(p.tests, testplugins[i](g)) + } +} + +func (p *plugin) Generate(file *generator.FileDescriptor) { + p.PluginImports = generator.NewPluginImports(p.Generator) + atLeastOne := false + for i := range p.tests { + used := p.tests[i].Generate(p.PluginImports, file) + if used { + atLeastOne = true + } + } + if atLeastOne { + p.P(`//These tests are generated by github.com/gogo/protobuf/plugin/testgen`) + } +} + +type testProto struct { + *generator.Generator +} + +func newProto(g *generator.Generator) TestPlugin { + return &testProto{g} +} + +func (p *testProto) Generate(imports generator.PluginImports, file *generator.FileDescriptor) bool { + used := false + testingPkg := imports.NewImport("testing") + randPkg := imports.NewImport("math/rand") + timePkg := imports.NewImport("time") + protoPkg := imports.NewImport("github.com/gogo/protobuf/proto") + if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) { + protoPkg = imports.NewImport("github.com/golang/protobuf/proto") + } + for _, message := range file.Messages() { + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + if gogoproto.HasTestGen(file.FileDescriptorProto, message.DescriptorProto) { + used = true + + p.P(`func Test`, ccTypeName, `Proto(t *`, testingPkg.Use(), `.T) {`) + p.In() + p.P(`seed := `, timePkg.Use(), `.Now().UnixNano()`) + p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(seed))`) + p.P(`p := NewPopulated`, ccTypeName, `(popr, false)`) + p.P(`data, err := `, protoPkg.Use(), `.Marshal(p)`) + p.P(`if err != nil {`) + p.In() + p.P(`t.Fatalf("seed = %d, err = %v", seed, err)`) + p.Out() + p.P(`}`) + p.P(`msg := &`, ccTypeName, `{}`) + p.P(`if err := `, protoPkg.Use(), `.Unmarshal(data, msg); err != nil {`) + p.In() + p.P(`t.Fatalf("seed = %d, err = %v", seed, err)`) + p.Out() + p.P(`}`) + p.P(`littlefuzz := make([]byte, len(data))`) + p.P(`copy(littlefuzz, data)`) + p.P(`for i := range data {`) + p.In() + p.P(`data[i] = byte(popr.Intn(256))`) + p.Out() + p.P(`}`) + if gogoproto.HasVerboseEqual(file.FileDescriptorProto, message.DescriptorProto) { + p.P(`if err := p.VerboseEqual(msg); err != nil {`) + p.In() + p.P(`t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)`) + p.Out() + p.P(`}`) + } + p.P(`if !p.Equal(msg) {`) + p.In() + p.P(`t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)`) + p.Out() + p.P(`}`) + p.P(`if len(littlefuzz) > 0 {`) + p.In() + p.P(`fuzzamount := 100`) + p.P(`for i := 0; i < fuzzamount; i++ {`) + p.In() + p.P(`littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256))`) + p.P(`littlefuzz = append(littlefuzz, byte(popr.Intn(256)))`) + p.Out() + p.P(`}`) + p.P(`// shouldn't panic`) + p.P(`_ = `, protoPkg.Use(), `.Unmarshal(littlefuzz, msg)`) + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + p.P() + } + + if gogoproto.HasTestGen(file.FileDescriptorProto, message.DescriptorProto) { + if gogoproto.IsMarshaler(file.FileDescriptorProto, message.DescriptorProto) || gogoproto.IsUnsafeMarshaler(file.FileDescriptorProto, message.DescriptorProto) { + p.P(`func Test`, ccTypeName, `MarshalTo(t *`, testingPkg.Use(), `.T) {`) + p.In() + p.P(`seed := `, timePkg.Use(), `.Now().UnixNano()`) + p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(seed))`) + p.P(`p := NewPopulated`, ccTypeName, `(popr, false)`) + p.P(`size := p.Size()`) + p.P(`data := make([]byte, size)`) + p.P(`for i := range data {`) + p.In() + p.P(`data[i] = byte(popr.Intn(256))`) + p.Out() + p.P(`}`) + p.P(`_, err := p.MarshalTo(data)`) + p.P(`if err != nil {`) + p.In() + p.P(`t.Fatalf("seed = %d, err = %v", seed, err)`) + p.Out() + p.P(`}`) + p.P(`msg := &`, ccTypeName, `{}`) + p.P(`if err := `, protoPkg.Use(), `.Unmarshal(data, msg); err != nil {`) + p.In() + p.P(`t.Fatalf("seed = %d, err = %v", seed, err)`) + p.Out() + p.P(`}`) + p.P(`for i := range data {`) + p.In() + p.P(`data[i] = byte(popr.Intn(256))`) + p.Out() + p.P(`}`) + if gogoproto.HasVerboseEqual(file.FileDescriptorProto, message.DescriptorProto) { + p.P(`if err := p.VerboseEqual(msg); err != nil {`) + p.In() + p.P(`t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)`) + p.Out() + p.P(`}`) + } + p.P(`if !p.Equal(msg) {`) + p.In() + p.P(`t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)`) + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + p.P() + } + } + + if gogoproto.HasBenchGen(file.FileDescriptorProto, message.DescriptorProto) { + used = true + p.P(`func Benchmark`, ccTypeName, `ProtoMarshal(b *`, testingPkg.Use(), `.B) {`) + p.In() + p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(616))`) + p.P(`total := 0`) + p.P(`pops := make([]*`, ccTypeName, `, 10000)`) + p.P(`for i := 0; i < 10000; i++ {`) + p.In() + p.P(`pops[i] = NewPopulated`, ccTypeName, `(popr, false)`) + p.Out() + p.P(`}`) + p.P(`b.ResetTimer()`) + p.P(`for i := 0; i < b.N; i++ {`) + p.In() + p.P(`data, err := `, protoPkg.Use(), `.Marshal(pops[i%10000])`) + p.P(`if err != nil {`) + p.In() + p.P(`panic(err)`) + p.Out() + p.P(`}`) + p.P(`total += len(data)`) + p.Out() + p.P(`}`) + p.P(`b.SetBytes(int64(total / b.N))`) + p.Out() + p.P(`}`) + p.P() + + p.P(`func Benchmark`, ccTypeName, `ProtoUnmarshal(b *`, testingPkg.Use(), `.B) {`) + p.In() + p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(616))`) + p.P(`total := 0`) + p.P(`datas := make([][]byte, 10000)`) + p.P(`for i := 0; i < 10000; i++ {`) + p.In() + p.P(`data, err := `, protoPkg.Use(), `.Marshal(NewPopulated`, ccTypeName, `(popr, false))`) + p.P(`if err != nil {`) + p.In() + p.P(`panic(err)`) + p.Out() + p.P(`}`) + p.P(`datas[i] = data`) + p.Out() + p.P(`}`) + p.P(`msg := &`, ccTypeName, `{}`) + p.P(`b.ResetTimer()`) + p.P(`for i := 0; i < b.N; i++ {`) + p.In() + p.P(`total += len(datas[i%10000])`) + p.P(`if err := `, protoPkg.Use(), `.Unmarshal(datas[i%10000], msg); err != nil {`) + p.In() + p.P(`panic(err)`) + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + p.P(`b.SetBytes(int64(total / b.N))`) + p.Out() + p.P(`}`) + p.P() + } + } + return used +} + +type testJson struct { + *generator.Generator +} + +func newJson(g *generator.Generator) TestPlugin { + return &testJson{g} +} + +func (p *testJson) Generate(imports generator.PluginImports, file *generator.FileDescriptor) bool { + used := false + testingPkg := imports.NewImport("testing") + randPkg := imports.NewImport("math/rand") + timePkg := imports.NewImport("time") + jsonPkg := imports.NewImport("github.com/gogo/protobuf/jsonpb") + for _, message := range file.Messages() { + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + if gogoproto.HasTestGen(file.FileDescriptorProto, message.DescriptorProto) { + used = true + p.P(`func Test`, ccTypeName, `JSON(t *`, testingPkg.Use(), `.T) {`) + p.In() + p.P(`seed := `, timePkg.Use(), `.Now().UnixNano()`) + p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(seed))`) + p.P(`p := NewPopulated`, ccTypeName, `(popr, true)`) + p.P(`marshaler := `, jsonPkg.Use(), `.Marshaler{}`) + p.P(`jsondata, err := marshaler.MarshalToString(p)`) + p.P(`if err != nil {`) + p.In() + p.P(`t.Fatalf("seed = %d, err = %v", seed, err)`) + p.Out() + p.P(`}`) + p.P(`msg := &`, ccTypeName, `{}`) + p.P(`err = `, jsonPkg.Use(), `.UnmarshalString(jsondata, msg)`) + p.P(`if err != nil {`) + p.In() + p.P(`t.Fatalf("seed = %d, err = %v", seed, err)`) + p.Out() + p.P(`}`) + if gogoproto.HasVerboseEqual(file.FileDescriptorProto, message.DescriptorProto) { + p.P(`if err := p.VerboseEqual(msg); err != nil {`) + p.In() + p.P(`t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)`) + p.Out() + p.P(`}`) + } + p.P(`if !p.Equal(msg) {`) + p.In() + p.P(`t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)`) + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + } + } + return used +} + +type testText struct { + *generator.Generator +} + +func newText(g *generator.Generator) TestPlugin { + return &testText{g} +} + +func (p *testText) Generate(imports generator.PluginImports, file *generator.FileDescriptor) bool { + used := false + testingPkg := imports.NewImport("testing") + randPkg := imports.NewImport("math/rand") + timePkg := imports.NewImport("time") + protoPkg := imports.NewImport("github.com/gogo/protobuf/proto") + if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) { + protoPkg = imports.NewImport("github.com/golang/protobuf/proto") + } + //fmtPkg := imports.NewImport("fmt") + for _, message := range file.Messages() { + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + if gogoproto.HasTestGen(file.FileDescriptorProto, message.DescriptorProto) { + used = true + + p.P(`func Test`, ccTypeName, `ProtoText(t *`, testingPkg.Use(), `.T) {`) + p.In() + p.P(`seed := `, timePkg.Use(), `.Now().UnixNano()`) + p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(seed))`) + p.P(`p := NewPopulated`, ccTypeName, `(popr, true)`) + p.P(`data := `, protoPkg.Use(), `.MarshalTextString(p)`) + p.P(`msg := &`, ccTypeName, `{}`) + p.P(`if err := `, protoPkg.Use(), `.UnmarshalText(data, msg); err != nil {`) + p.In() + p.P(`t.Fatalf("seed = %d, err = %v", seed, err)`) + p.Out() + p.P(`}`) + if gogoproto.HasVerboseEqual(file.FileDescriptorProto, message.DescriptorProto) { + p.P(`if err := p.VerboseEqual(msg); err != nil {`) + p.In() + p.P(`t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)`) + p.Out() + p.P(`}`) + } + p.P(`if !p.Equal(msg) {`) + p.In() + p.P(`t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)`) + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + p.P() + + p.P(`func Test`, ccTypeName, `ProtoCompactText(t *`, testingPkg.Use(), `.T) {`) + p.In() + p.P(`seed := `, timePkg.Use(), `.Now().UnixNano()`) + p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(seed))`) + p.P(`p := NewPopulated`, ccTypeName, `(popr, true)`) + p.P(`data := `, protoPkg.Use(), `.CompactTextString(p)`) + p.P(`msg := &`, ccTypeName, `{}`) + p.P(`if err := `, protoPkg.Use(), `.UnmarshalText(data, msg); err != nil {`) + p.In() + p.P(`t.Fatalf("seed = %d, err = %v", seed, err)`) + p.Out() + p.P(`}`) + if gogoproto.HasVerboseEqual(file.FileDescriptorProto, message.DescriptorProto) { + p.P(`if err := p.VerboseEqual(msg); err != nil {`) + p.In() + p.P(`t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err)`) + p.Out() + p.P(`}`) + } + p.P(`if !p.Equal(msg) {`) + p.In() + p.P(`t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p)`) + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + p.P() + + } + } + return used +} + +func init() { + RegisterTestPlugin(newProto) + RegisterTestPlugin(newJson) + RegisterTestPlugin(newText) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/union/union.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/union/union.go new file mode 100644 index 0000000000000000000000000000000000000000..3c2edbda0d928686a71e0e4f81a2d6a8561399a6 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/union/union.go @@ -0,0 +1,207 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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. + +/* +The onlyone plugin generates code for the onlyone extension. +All fields must be nullable and only one of the fields may be set, like a union. +Two methods are generated + + GetValue() interface{} + +and + + SetValue(v interface{}) (set bool) + +These provide easier interaction with a onlyone. + +The onlyone extension is not called union as this causes compile errors in the C++ generated code. +There can only be one ;) + +It is enabled by the following extensions: + + - onlyone + - onlyone_all + +The onlyone plugin also generates a test given it is enabled using one of the following extensions: + + - testgen + - testgen_all + +Lets look at: + + github.com/gogo/protobuf/test/example/example.proto + +Btw all the output can be seen at: + + github.com/gogo/protobuf/test/example/* + +The following message: + + message U { + option (gogoproto.onlyone) = true; + optional A A = 1; + optional B B = 2; + } + +given to the onlyone plugin, will generate code which looks a lot like this: + + func (this *U) GetValue() interface{} { + if this.A != nil { + return this.A + } + if this.B != nil { + return this.B + } + return nil + } + + func (this *U) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *A: + this.A = vt + case *B: + this.B = vt + default: + return false + } + return true + } + +and the following test code: + + func TestUUnion(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedU(popr) + v := p.GetValue() + msg := &U{} + if !msg.SetValue(v) { + t.Fatalf("Union: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !Union Equal %#v", msg, p) + } + } + +*/ +package union + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" +) + +type union struct { + *generator.Generator + generator.PluginImports +} + +func NewUnion() *union { + return &union{} +} + +func (p *union) Name() string { + return "union" +} + +func (p *union) Init(g *generator.Generator) { + p.Generator = g +} + +func (p *union) Generate(file *generator.FileDescriptor) { + p.PluginImports = generator.NewPluginImports(p.Generator) + + for _, message := range file.Messages() { + if !gogoproto.IsUnion(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if message.DescriptorProto.HasExtension() { + panic("onlyone does not currently support extensions") + } + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + p.P(`func (this *`, ccTypeName, `) GetValue() interface{} {`) + p.In() + for _, field := range message.Field { + fieldname := p.GetFieldName(message, field) + if fieldname == "Value" { + panic("cannot have a onlyone message " + ccTypeName + " with a field named Value") + } + p.P(`if this.`, fieldname, ` != nil {`) + p.In() + p.P(`return this.`, fieldname) + p.Out() + p.P(`}`) + } + p.P(`return nil`) + p.Out() + p.P(`}`) + p.P(``) + p.P(`func (this *`, ccTypeName, `) SetValue(value interface{}) bool {`) + p.In() + p.P(`switch vt := value.(type) {`) + p.In() + for _, field := range message.Field { + fieldname := p.GetFieldName(message, field) + goTyp, _ := p.GoType(message, field) + p.P(`case `, goTyp, `:`) + p.In() + p.P(`this.`, fieldname, ` = vt`) + p.Out() + } + p.P(`default:`) + p.In() + for _, field := range message.Field { + fieldname := p.GetFieldName(message, field) + if field.IsMessage() { + goTyp, _ := p.GoType(message, field) + obj := p.ObjectNamed(field.GetTypeName()).(*generator.Descriptor) + + if gogoproto.IsUnion(obj.File(), obj.DescriptorProto) { + p.P(`this.`, fieldname, ` = new(`, generator.GoTypeToName(goTyp), `)`) + p.P(`if set := this.`, fieldname, `.SetValue(value); set {`) + p.In() + p.P(`return true`) + p.Out() + p.P(`}`) + p.P(`this.`, fieldname, ` = nil`) + } + } + } + p.P(`return false`) + p.Out() + p.P(`}`) + p.P(`return true`) + p.Out() + p.P(`}`) + } +} + +func init() { + generator.RegisterPlugin(NewUnion()) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/union/uniontest.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/union/uniontest.go new file mode 100644 index 0000000000000000000000000000000000000000..03120e19d5d88ced8f911a1ab95783055b0b068c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/union/uniontest.go @@ -0,0 +1,84 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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 union + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/testgen" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" +) + +type test struct { + *generator.Generator +} + +func NewTest(g *generator.Generator) testgen.TestPlugin { + return &test{g} +} + +func (p *test) Generate(imports generator.PluginImports, file *generator.FileDescriptor) bool { + used := false + randPkg := imports.NewImport("math/rand") + timePkg := imports.NewImport("time") + testingPkg := imports.NewImport("testing") + for _, message := range file.Messages() { + if !gogoproto.IsUnion(file.FileDescriptorProto, message.DescriptorProto) || + !gogoproto.HasTestGen(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + used = true + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + + p.P(`func Test`, ccTypeName, `OnlyOne(t *`, testingPkg.Use(), `.T) {`) + p.In() + p.P(`popr := `, randPkg.Use(), `.New(`, randPkg.Use(), `.NewSource(`, timePkg.Use(), `.Now().UnixNano()))`) + p.P(`p := NewPopulated`, ccTypeName, `(popr, true)`) + p.P(`v := p.GetValue()`) + p.P(`msg := &`, ccTypeName, `{}`) + p.P(`if !msg.SetValue(v) {`) + p.In() + p.P(`t.Fatalf("OnlyOne: Could not set Value")`) + p.Out() + p.P(`}`) + p.P(`if !p.Equal(msg) {`) + p.In() + p.P(`t.Fatalf("%#v !OnlyOne Equal %#v", msg, p)`) + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + + } + return used +} + +func init() { + testgen.RegisterTestPlugin(NewTest) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/unmarshal/unmarshal.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/unmarshal/unmarshal.go new file mode 100644 index 0000000000000000000000000000000000000000..d92739247225da5777d1e9ecf2a15f868fc5b0c0 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/unmarshal/unmarshal.go @@ -0,0 +1,1298 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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. + +/* +The unmarshal plugin generates a Unmarshal method for each message. +The `Unmarshal([]byte) error` method results in the fact that the message +implements the Unmarshaler interface. +The allows proto.Unmarshal to be faster by calling the generated Unmarshal method rather than using reflect. + +If is enabled by the following extensions: + + - unmarshaler + - unmarshaler_all + +Or the following extensions: + + - unsafe_unmarshaler + - unsafe_unmarshaler_all + +That is if you want to use the unsafe package in your generated code. +The speed up using the unsafe package is not very significant. + +The generation of unmarshalling tests are enabled using one of the following extensions: + + - testgen + - testgen_all + +And benchmarks given it is enabled using one of the following extensions: + + - benchgen + - benchgen_all + +Let us look at: + + github.com/gogo/protobuf/test/example/example.proto + +Btw all the output can be seen at: + + github.com/gogo/protobuf/test/example/* + +The following message: + + option (gogoproto.unmarshaler_all) = true; + + message B { + option (gogoproto.description) = true; + optional A A = 1 [(gogoproto.nullable) = false, (gogoproto.embed) = true]; + repeated bytes G = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; + } + +given to the unmarshal plugin, will generate the following code: + + func (m *B) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + switch fieldNum { + case 1: + if wireType != 2 { + return proto.ErrWrongType + } + var msglen int + for shift := uint(0); ; shift += 7 { + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.A.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return proto.ErrWrongType + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.G = append(m.G, github_com_gogo_protobuf_test_custom.Uint128{}) + if err := m.G[len(m.G)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + iNdEx -= sizeOfWire + skippy, err := skip(data[iNdEx:]) + if err != nil { + return err + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + return nil + } + +Remember when using this code to call proto.Unmarshal. +This will call m.Reset and invoke the generated Unmarshal method for you. +If you call m.Unmarshal without m.Reset you could be merging protocol buffers. + +*/ +package unmarshal + +import ( + "fmt" + "strconv" + "strings" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + descriptor "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" +) + +type unmarshal struct { + *generator.Generator + unsafe bool + generator.PluginImports + atleastOne bool + ioPkg generator.Single + mathPkg generator.Single + unsafePkg generator.Single + localName string +} + +func NewUnmarshal() *unmarshal { + return &unmarshal{} +} + +func NewUnsafeUnmarshal() *unmarshal { + return &unmarshal{unsafe: true} +} + +func (p *unmarshal) Name() string { + if p.unsafe { + return "unsafeunmarshaler" + } + return "unmarshal" +} + +func (p *unmarshal) Init(g *generator.Generator) { + p.Generator = g +} + +func (p *unmarshal) decodeVarint(varName string, typName string) { + p.P(`for shift := uint(0); ; shift += 7 {`) + p.In() + p.P(`if shift >= 64 {`) + p.In() + p.P(`return ErrIntOverflow` + p.localName) + p.Out() + p.P(`}`) + p.P(`if iNdEx >= l {`) + p.In() + p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`) + p.Out() + p.P(`}`) + p.P(`b := data[iNdEx]`) + p.P(`iNdEx++`) + p.P(varName, ` |= (`, typName, `(b) & 0x7F) << shift`) + p.P(`if b < 0x80 {`) + p.In() + p.P(`break`) + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) +} + +func (p *unmarshal) decodeFixed32(varName string, typeName string) { + p.P(`if (iNdEx+4) > l {`) + p.In() + p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`) + p.Out() + p.P(`}`) + p.P(`iNdEx += 4`) + p.P(varName, ` = `, typeName, `(data[iNdEx-4])`) + p.P(varName, ` |= `, typeName, `(data[iNdEx-3]) << 8`) + p.P(varName, ` |= `, typeName, `(data[iNdEx-2]) << 16`) + p.P(varName, ` |= `, typeName, `(data[iNdEx-1]) << 24`) +} + +func (p *unmarshal) unsafeFixed32(varName string, typeName string) { + p.P(`if iNdEx + 4 > l {`) + p.In() + p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`) + p.Out() + p.P(`}`) + p.P(varName, ` = *(*`, typeName, `)(`, p.unsafePkg.Use(), `.Pointer(&data[iNdEx]))`) + p.P(`iNdEx += 4`) +} + +func (p *unmarshal) decodeFixed64(varName string, typeName string) { + p.P(`if (iNdEx+8) > l {`) + p.In() + p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`) + p.Out() + p.P(`}`) + p.P(`iNdEx += 8`) + p.P(varName, ` = `, typeName, `(data[iNdEx-8])`) + p.P(varName, ` |= `, typeName, `(data[iNdEx-7]) << 8`) + p.P(varName, ` |= `, typeName, `(data[iNdEx-6]) << 16`) + p.P(varName, ` |= `, typeName, `(data[iNdEx-5]) << 24`) + p.P(varName, ` |= `, typeName, `(data[iNdEx-4]) << 32`) + p.P(varName, ` |= `, typeName, `(data[iNdEx-3]) << 40`) + p.P(varName, ` |= `, typeName, `(data[iNdEx-2]) << 48`) + p.P(varName, ` |= `, typeName, `(data[iNdEx-1]) << 56`) +} + +func (p *unmarshal) unsafeFixed64(varName string, typeName string) { + p.P(`if iNdEx + 8 > l {`) + p.In() + p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`) + p.Out() + p.P(`}`) + p.P(varName, ` = *(*`, typeName, `)(`, p.unsafePkg.Use(), `.Pointer(&data[iNdEx]))`) + p.P(`iNdEx += 8`) +} + +func (p *unmarshal) mapField(varName string, field *descriptor.FieldDescriptorProto) { + switch field.GetType() { + case descriptor.FieldDescriptorProto_TYPE_DOUBLE: + p.P(`var `, varName, `temp uint64`) + p.decodeFixed64(varName+"temp", "uint64") + p.P(varName, ` := `, p.mathPkg.Use(), `.Float64frombits(`, varName, `temp)`) + case descriptor.FieldDescriptorProto_TYPE_FLOAT: + p.P(`var `, varName, `temp uint32`) + p.decodeFixed32(varName+"temp", "uint32") + p.P(varName, ` := `, p.mathPkg.Use(), `.Float32frombits(`, varName, `temp)`) + case descriptor.FieldDescriptorProto_TYPE_INT64: + p.P(`var `, varName, ` int64`) + p.decodeVarint(varName, "int64") + case descriptor.FieldDescriptorProto_TYPE_UINT64: + p.P(`var `, varName, ` uint64`) + p.decodeVarint(varName, "uint64") + case descriptor.FieldDescriptorProto_TYPE_INT32: + p.P(`var `, varName, ` int32`) + p.decodeVarint(varName, "int32") + case descriptor.FieldDescriptorProto_TYPE_FIXED64: + p.P(`var `, varName, ` uint64`) + p.decodeFixed64(varName, "uint64") + case descriptor.FieldDescriptorProto_TYPE_FIXED32: + p.P(`var `, varName, ` uint32`) + p.decodeFixed32(varName, "uint32") + case descriptor.FieldDescriptorProto_TYPE_BOOL: + p.P(`var `, varName, `temp int`) + p.decodeVarint(varName+"temp", "int") + p.P(varName, ` := bool(`, varName, `temp != 0)`) + case descriptor.FieldDescriptorProto_TYPE_STRING: + p.P(`var stringLen`, varName, ` uint64`) + p.decodeVarint("stringLen"+varName, "uint64") + p.P(`intStringLen`, varName, ` := int(stringLen`, varName, `)`) + p.P(`if intStringLen`, varName, ` < 0 {`) + p.In() + p.P(`return ErrInvalidLength` + p.localName) + p.Out() + p.P(`}`) + p.P(`postStringIndex`, varName, ` := iNdEx + intStringLen`, varName) + p.P(`if postStringIndex`, varName, ` > l {`) + p.In() + p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`) + p.Out() + p.P(`}`) + p.P(varName, ` := string(data[iNdEx:postStringIndex`, varName, `])`) + p.P(`iNdEx = postStringIndex`, varName) + case descriptor.FieldDescriptorProto_TYPE_MESSAGE: + p.P(`var mapmsglen int`) + p.decodeVarint("mapmsglen", "int") + p.P(`if mapmsglen < 0 {`) + p.In() + p.P(`return ErrInvalidLength` + p.localName) + p.Out() + p.P(`}`) + p.P(`postmsgIndex := iNdEx + mapmsglen`) + p.P(`if mapmsglen < 0 {`) + p.In() + p.P(`return ErrInvalidLength` + p.localName) + p.Out() + p.P(`}`) + p.P(`if postmsgIndex > l {`) + p.In() + p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`) + p.Out() + p.P(`}`) + desc := p.ObjectNamed(field.GetTypeName()) + msgname := p.TypeName(desc) + p.P(varName, ` := &`, msgname, `{}`) + p.P(`if err := `, varName, `.Unmarshal(data[iNdEx:postmsgIndex]); err != nil {`) + p.In() + p.P(`return err`) + p.Out() + p.P(`}`) + p.P(`iNdEx = postmsgIndex`) + case descriptor.FieldDescriptorProto_TYPE_BYTES: + p.P(`var mapbyteLen uint64`) + p.decodeVarint("mapbyteLen", "uint64") + p.P(`intMapbyteLen := int(mapbyteLen)`) + p.P(`if intMapbyteLen < 0 {`) + p.In() + p.P(`return ErrInvalidLength` + p.localName) + p.Out() + p.P(`}`) + p.P(`postbytesIndex := iNdEx + intMapbyteLen`) + p.P(`if postbytesIndex > l {`) + p.In() + p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`) + p.Out() + p.P(`}`) + p.P(varName, ` := make([]byte, mapbyteLen)`) + p.P(`copy(`, varName, `, data[iNdEx:postbytesIndex])`) + p.P(`iNdEx = postbytesIndex`) + case descriptor.FieldDescriptorProto_TYPE_UINT32: + p.P(`var `, varName, ` uint32`) + p.decodeVarint(varName, "uint32") + case descriptor.FieldDescriptorProto_TYPE_ENUM: + typName := p.TypeName(p.ObjectNamed(field.GetTypeName())) + p.P(`var `, varName, ` `, typName) + p.decodeVarint(varName, typName) + case descriptor.FieldDescriptorProto_TYPE_SFIXED32: + p.P(`var `, varName, ` int32`) + p.decodeFixed32(varName, "int32") + case descriptor.FieldDescriptorProto_TYPE_SFIXED64: + p.P(`var `, varName, ` int64`) + p.decodeFixed64(varName, "int64") + case descriptor.FieldDescriptorProto_TYPE_SINT32: + p.P(`var `, varName, `temp int32`) + p.decodeVarint(varName+"temp", "int32") + p.P(varName, `temp = int32((uint32(`, varName, `temp) >> 1) ^ uint32(((`, varName, `temp&1)<<31)>>31))`) + p.P(varName, ` := int32(`, varName, `temp)`) + case descriptor.FieldDescriptorProto_TYPE_SINT64: + p.P(`var `, varName, `temp uint64`) + p.decodeVarint(varName+"temp", "uint64") + p.P(varName, `temp = (`, varName, `temp >> 1) ^ uint64((int64(`, varName, `temp&1)<<63)>>63)`) + p.P(varName, ` := int64(`, varName, `temp)`) + } +} + +func (p *unmarshal) noStarOrSliceType(msg *generator.Descriptor, field *descriptor.FieldDescriptorProto) string { + typ, _ := p.GoType(msg, field) + if typ[0] == '*' { + return typ[1:] + } + if typ[0] == '[' && typ[1] == ']' { + return typ[2:] + } + return typ +} + +func (p *unmarshal) field(file *descriptor.FileDescriptorProto, msg *generator.Descriptor, field *descriptor.FieldDescriptorProto, fieldname string, proto3 bool) { + repeated := field.IsRepeated() + nullable := gogoproto.IsNullable(field) + typ := p.noStarOrSliceType(msg, field) + oneof := field.OneofIndex != nil + switch *field.Type { + case descriptor.FieldDescriptorProto_TYPE_DOUBLE: + if !p.unsafe || gogoproto.IsCastType(field) { + p.P(`var v uint64`) + p.decodeFixed64("v", "uint64") + if oneof { + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{`, typ, "(", p.mathPkg.Use(), `.Float64frombits(v))}`) + } else if repeated { + p.P(`v2 := `, typ, "(", p.mathPkg.Use(), `.Float64frombits(v))`) + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v2)`) + } else if proto3 || !nullable { + p.P(`m.`, fieldname, ` = `, typ, "(", p.mathPkg.Use(), `.Float64frombits(v))`) + } else { + p.P(`v2 := `, typ, "(", p.mathPkg.Use(), `.Float64frombits(v))`) + p.P(`m.`, fieldname, ` = &v2`) + } + } else { + if oneof { + p.P(`var v float64`) + p.unsafeFixed64("v", "float64") + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if repeated { + p.P(`var v float64`) + p.unsafeFixed64("v", "float64") + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`) + } else if proto3 || !nullable { + p.unsafeFixed64(`m.`+fieldname, "float64") + } else { + p.P(`var v float64`) + p.unsafeFixed64("v", "float64") + p.P(`m.`, fieldname, ` = &v`) + } + } + case descriptor.FieldDescriptorProto_TYPE_FLOAT: + if !p.unsafe || gogoproto.IsCastType(field) { + p.P(`var v uint32`) + p.decodeFixed32("v", "uint32") + if oneof { + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{`, typ, "(", p.mathPkg.Use(), `.Float32frombits(v))}`) + } else if repeated { + p.P(`v2 := `, typ, "(", p.mathPkg.Use(), `.Float32frombits(v))`) + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v2)`) + } else if proto3 || !nullable { + p.P(`m.`, fieldname, ` = `, typ, "(", p.mathPkg.Use(), `.Float32frombits(v))`) + } else { + p.P(`v2 := `, typ, "(", p.mathPkg.Use(), `.Float32frombits(v))`) + p.P(`m.`, fieldname, ` = &v2`) + } + } else { + if oneof { + p.P(`var v float32`) + p.unsafeFixed32("v", "float32") + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if repeated { + p.P(`var v float32`) + p.unsafeFixed32("v", "float32") + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`) + } else if proto3 || !nullable { + p.unsafeFixed32("m."+fieldname, "float32") + } else { + p.P(`var v float32`) + p.unsafeFixed32("v", "float32") + p.P(`m.`, fieldname, ` = &v`) + } + } + case descriptor.FieldDescriptorProto_TYPE_INT64: + if oneof { + p.P(`var v `, typ) + p.decodeVarint("v", typ) + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if repeated { + p.P(`var v `, typ) + p.decodeVarint("v", typ) + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`) + } else if proto3 || !nullable { + p.P(`m.`, fieldname, ` = 0`) + p.decodeVarint("m."+fieldname, typ) + } else { + p.P(`var v `, typ) + p.decodeVarint("v", typ) + p.P(`m.`, fieldname, ` = &v`) + } + case descriptor.FieldDescriptorProto_TYPE_UINT64: + if oneof { + p.P(`var v `, typ) + p.decodeVarint("v", typ) + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if repeated { + p.P(`var v `, typ) + p.decodeVarint("v", typ) + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`) + } else if proto3 || !nullable { + p.P(`m.`, fieldname, ` = 0`) + p.decodeVarint("m."+fieldname, typ) + } else { + p.P(`var v `, typ) + p.decodeVarint("v", typ) + p.P(`m.`, fieldname, ` = &v`) + } + case descriptor.FieldDescriptorProto_TYPE_INT32: + if oneof { + p.P(`var v `, typ) + p.decodeVarint("v", typ) + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if repeated { + p.P(`var v `, typ) + p.decodeVarint("v", typ) + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`) + } else if proto3 || !nullable { + p.P(`m.`, fieldname, ` = 0`) + p.decodeVarint("m."+fieldname, typ) + } else { + p.P(`var v `, typ) + p.decodeVarint("v", typ) + p.P(`m.`, fieldname, ` = &v`) + } + case descriptor.FieldDescriptorProto_TYPE_FIXED64: + if !p.unsafe || gogoproto.IsCastType(field) { + if oneof { + p.P(`var v `, typ) + p.decodeFixed64("v", typ) + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if repeated { + p.P(`var v `, typ) + p.decodeFixed64("v", typ) + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`) + } else if proto3 || !nullable { + p.P(`m.`, fieldname, ` = 0`) + p.decodeFixed64("m."+fieldname, typ) + } else { + p.P(`var v `, typ) + p.decodeFixed64("v", typ) + p.P(`m.`, fieldname, ` = &v`) + } + } else { + if oneof { + p.P(`var v uint64`) + p.unsafeFixed64("v", "uint64") + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if repeated { + p.P(`var v uint64`) + p.unsafeFixed64("v", "uint64") + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`) + } else if proto3 || !nullable { + p.unsafeFixed64("m."+fieldname, "uint64") + } else { + p.P(`var v uint64`) + p.unsafeFixed64("v", "uint64") + p.P(`m.`, fieldname, ` = &v`) + } + } + case descriptor.FieldDescriptorProto_TYPE_FIXED32: + if !p.unsafe || gogoproto.IsCastType(field) { + if oneof { + p.P(`var v `, typ) + p.decodeFixed32("v", typ) + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if repeated { + p.P(`var v `, typ) + p.decodeFixed32("v", typ) + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`) + } else if proto3 || !nullable { + p.P(`m.`, fieldname, ` = 0`) + p.decodeFixed32("m."+fieldname, typ) + } else { + p.P(`var v `, typ) + p.decodeFixed32("v", typ) + p.P(`m.`, fieldname, ` = &v`) + } + } else { + if oneof { + p.P(`var v uint32`) + p.unsafeFixed32("v", "uint32") + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if repeated { + p.P(`var v uint32`) + p.unsafeFixed32("v", "uint32") + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`) + } else if proto3 || !nullable { + p.unsafeFixed32("m."+fieldname, "uint32") + } else { + p.P(`var v uint32`) + p.unsafeFixed32("v", "uint32") + p.P(`m.`, fieldname, ` = &v`) + } + } + case descriptor.FieldDescriptorProto_TYPE_BOOL: + p.P(`var v int`) + p.decodeVarint("v", "int") + if oneof { + p.P(`b := `, typ, `(v != 0)`) + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{b}`) + } else if repeated { + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, `, typ, `(v != 0))`) + } else if proto3 || !nullable { + p.P(`m.`, fieldname, ` = `, typ, `(v != 0)`) + } else { + p.P(`b := `, typ, `(v != 0)`) + p.P(`m.`, fieldname, ` = &b`) + } + case descriptor.FieldDescriptorProto_TYPE_STRING: + p.P(`var stringLen uint64`) + p.decodeVarint("stringLen", "uint64") + p.P(`intStringLen := int(stringLen)`) + p.P(`if intStringLen < 0 {`) + p.In() + p.P(`return ErrInvalidLength` + p.localName) + p.Out() + p.P(`}`) + p.P(`postIndex := iNdEx + intStringLen`) + p.P(`if postIndex > l {`) + p.In() + p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`) + p.Out() + p.P(`}`) + if oneof { + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{`, typ, `(data[iNdEx:postIndex])}`) + } else if repeated { + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, `, typ, `(data[iNdEx:postIndex]))`) + } else if proto3 || !nullable { + p.P(`m.`, fieldname, ` = `, typ, `(data[iNdEx:postIndex])`) + } else { + p.P(`s := `, typ, `(data[iNdEx:postIndex])`) + p.P(`m.`, fieldname, ` = &s`) + } + p.P(`iNdEx = postIndex`) + case descriptor.FieldDescriptorProto_TYPE_GROUP: + panic(fmt.Errorf("unmarshaler does not support group %v", fieldname)) + case descriptor.FieldDescriptorProto_TYPE_MESSAGE: + desc := p.ObjectNamed(field.GetTypeName()) + msgname := p.TypeName(desc) + p.P(`var msglen int`) + p.decodeVarint("msglen", "int") + p.P(`if msglen < 0 {`) + p.In() + p.P(`return ErrInvalidLength` + p.localName) + p.Out() + p.P(`}`) + p.P(`postIndex := iNdEx + msglen`) + p.P(`if postIndex > l {`) + p.In() + p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`) + p.Out() + p.P(`}`) + if oneof { + p.P(`v := &`, msgname, `{}`) + p.P(`if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil {`) + p.In() + p.P(`return err`) + p.Out() + p.P(`}`) + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if generator.IsMap(file, field) { + mapMsg := generator.GetMap(file, field) + keyField, valueField := mapMsg.GetMapFields() + keygoTyp, _ := p.GoType(nil, keyField) + keygoTyp = strings.Replace(keygoTyp, "*", "", 1) + valuegoTyp, _ := p.GoType(nil, valueField) + if !valueField.IsMessage() { + valuegoTyp = strings.Replace(valuegoTyp, "*", "", 1) + } + p.P(`var keykey uint64`) + p.decodeVarint("keykey", "uint64") + p.mapField("mapkey", keyField) + p.P(`var valuekey uint64`) + p.decodeVarint("valuekey", "uint64") + p.mapField("mapvalue", valueField) + p.P(`if m.`, fieldname, ` == nil {`) + p.In() + p.P(`m.`, fieldname, ` = make(map[`, keygoTyp, `]`, valuegoTyp, `)`) + p.Out() + p.P(`}`) + p.P(`m.`, fieldname, `[mapkey] = mapvalue`) + } else if repeated { + if nullable { + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, &`, msgname, `{})`) + } else { + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, `, msgname, `{})`) + } + p.P(`if err := m.`, fieldname, `[len(m.`, fieldname, `)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {`) + p.In() + p.P(`return err`) + p.Out() + p.P(`}`) + } else if nullable { + p.P(`if m.`, fieldname, ` == nil {`) + p.In() + p.P(`m.`, fieldname, ` = &`, msgname, `{}`) + p.Out() + p.P(`}`) + p.P(`if err := m.`, fieldname, `.Unmarshal(data[iNdEx:postIndex]); err != nil {`) + p.In() + p.P(`return err`) + p.Out() + p.P(`}`) + } else { + p.P(`if err := m.`, fieldname, `.Unmarshal(data[iNdEx:postIndex]); err != nil {`) + p.In() + p.P(`return err`) + p.Out() + p.P(`}`) + } + p.P(`iNdEx = postIndex`) + case descriptor.FieldDescriptorProto_TYPE_BYTES: + p.P(`var byteLen int`) + p.decodeVarint("byteLen", "int") + p.P(`if byteLen < 0 {`) + p.In() + p.P(`return ErrInvalidLength` + p.localName) + p.Out() + p.P(`}`) + p.P(`postIndex := iNdEx + byteLen`) + p.P(`if postIndex > l {`) + p.In() + p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`) + p.Out() + p.P(`}`) + if !gogoproto.IsCustomType(field) { + if oneof { + p.P(`v := make([]byte, postIndex-iNdEx)`) + p.P(`copy(v, data[iNdEx:postIndex])`) + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if repeated { + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, make([]byte, postIndex-iNdEx))`) + p.P(`copy(m.`, fieldname, `[len(m.`, fieldname, `)-1], data[iNdEx:postIndex])`) + } else { + p.P(`m.`, fieldname, ` = append([]byte{}`, `, data[iNdEx:postIndex]...)`) + } + } else { + _, ctyp, err := generator.GetCustomType(field) + if err != nil { + panic(err) + } + if oneof { + p.P(`var vv `, ctyp) + p.P(`v := &vv`) + p.P(`if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil {`) + p.In() + p.P(`return err`) + p.Out() + p.P(`}`) + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{*v}`) + } else if repeated { + p.P(`var v `, ctyp) + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`) + p.P(`if err := m.`, fieldname, `[len(m.`, fieldname, `)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {`) + p.In() + p.P(`return err`) + p.Out() + p.P(`}`) + } else if nullable { + p.P(`var v `, ctyp) + p.P(`m.`, fieldname, ` = &v`) + p.P(`if err := m.`, fieldname, `.Unmarshal(data[iNdEx:postIndex]); err != nil {`) + p.In() + p.P(`return err`) + p.Out() + p.P(`}`) + } else { + p.P(`if err := m.`, fieldname, `.Unmarshal(data[iNdEx:postIndex]); err != nil {`) + p.In() + p.P(`return err`) + p.Out() + p.P(`}`) + } + } + p.P(`iNdEx = postIndex`) + case descriptor.FieldDescriptorProto_TYPE_UINT32: + if oneof { + p.P(`var v `, typ) + p.decodeVarint("v", typ) + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if repeated { + p.P(`var v `, typ) + p.decodeVarint("v", typ) + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`) + } else if proto3 || !nullable { + p.P(`m.`, fieldname, ` = 0`) + p.decodeVarint("m."+fieldname, typ) + } else { + p.P(`var v `, typ) + p.decodeVarint("v", typ) + p.P(`m.`, fieldname, ` = &v`) + } + case descriptor.FieldDescriptorProto_TYPE_ENUM: + typName := p.TypeName(p.ObjectNamed(field.GetTypeName())) + if oneof { + p.P(`var v `, typName) + p.decodeVarint("v", typName) + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if repeated { + p.P(`var v `, typName) + p.decodeVarint("v", typName) + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`) + } else if proto3 || !nullable { + p.P(`m.`, fieldname, ` = 0`) + p.decodeVarint("m."+fieldname, typName) + } else { + p.P(`var v `, typName) + p.decodeVarint("v", typName) + p.P(`m.`, fieldname, ` = &v`) + } + case descriptor.FieldDescriptorProto_TYPE_SFIXED32: + if !p.unsafe || gogoproto.IsCastType(field) { + if oneof { + p.P(`var v `, typ) + p.decodeFixed32("v", typ) + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if repeated { + p.P(`var v `, typ) + p.decodeFixed32("v", typ) + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`) + } else if proto3 || !nullable { + p.P(`m.`, fieldname, ` = 0`) + p.decodeFixed32("m."+fieldname, typ) + } else { + p.P(`var v `, typ) + p.decodeFixed32("v", typ) + p.P(`m.`, fieldname, ` = &v`) + } + } else { + if oneof { + p.P(`var v int32`) + p.unsafeFixed32("v", "int32") + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if repeated { + p.P(`var v int32`) + p.unsafeFixed32("v", "int32") + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`) + } else if proto3 || !nullable { + p.unsafeFixed32("m."+fieldname, "int32") + } else { + p.P(`var v int32`) + p.unsafeFixed32("v", "int32") + p.P(`m.`, fieldname, ` = &v`) + } + } + case descriptor.FieldDescriptorProto_TYPE_SFIXED64: + if !p.unsafe || gogoproto.IsCastType(field) { + if oneof { + p.P(`var v `, typ) + p.decodeFixed64("v", typ) + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if repeated { + p.P(`var v `, typ) + p.decodeFixed64("v", typ) + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`) + } else if proto3 || !nullable { + p.P(`m.`, fieldname, ` = 0`) + p.decodeFixed64("m."+fieldname, typ) + } else { + p.P(`var v `, typ) + p.decodeFixed64("v", typ) + p.P(`m.`, fieldname, ` = &v`) + } + } else { + if oneof { + p.P(`var v int64`) + p.unsafeFixed64("v", "int64") + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if repeated { + p.P(`var v int64`) + p.unsafeFixed64("v", "int64") + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`) + } else if proto3 || !nullable { + p.unsafeFixed64("m."+fieldname, "int64") + } else { + p.P(`var v int64`) + p.unsafeFixed64("v", "int64") + p.P(`m.`, fieldname, ` = &v`) + } + } + case descriptor.FieldDescriptorProto_TYPE_SINT32: + p.P(`var v `, typ) + p.decodeVarint("v", typ) + p.P(`v = `, typ, `((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))`) + if oneof { + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{v}`) + } else if repeated { + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, v)`) + } else if proto3 || !nullable { + p.P(`m.`, fieldname, ` = v`) + } else { + p.P(`m.`, fieldname, ` = &v`) + } + case descriptor.FieldDescriptorProto_TYPE_SINT64: + p.P(`var v uint64`) + p.decodeVarint("v", "uint64") + p.P(`v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)`) + if oneof { + p.P(`m.`, fieldname, ` = &`, p.OneOfTypeName(msg, field), `{`, typ, `(v)}`) + } else if repeated { + p.P(`m.`, fieldname, ` = append(m.`, fieldname, `, `, typ, `(v))`) + } else if proto3 || !nullable { + p.P(`m.`, fieldname, ` = `, typ, `(v)`) + } else { + p.P(`v2 := `, typ, `(v)`) + p.P(`m.`, fieldname, ` = &v2`) + } + default: + panic("not implemented") + } +} + +func (p *unmarshal) Generate(file *generator.FileDescriptor) { + proto3 := gogoproto.IsProto3(file.FileDescriptorProto) + p.PluginImports = generator.NewPluginImports(p.Generator) + p.atleastOne = false + p.localName = generator.FileName(file) + if p.unsafe { + p.localName += "Unsafe" + } + + p.ioPkg = p.NewImport("io") + p.mathPkg = p.NewImport("math") + p.unsafePkg = p.NewImport("unsafe") + fmtPkg := p.NewImport("fmt") + protoPkg := p.NewImport("github.com/gogo/protobuf/proto") + if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) { + protoPkg = p.NewImport("github.com/golang/protobuf/proto") + } + + for _, message := range file.Messages() { + ccTypeName := generator.CamelCaseSlice(message.TypeName()) + if p.unsafe { + if !gogoproto.IsUnsafeUnmarshaler(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if gogoproto.IsUnmarshaler(file.FileDescriptorProto, message.DescriptorProto) { + panic(fmt.Sprintf("unsafe_unmarshaler and unmarshaler enabled for %v", ccTypeName)) + } + } + if !p.unsafe { + if !gogoproto.IsUnmarshaler(file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if gogoproto.IsUnsafeUnmarshaler(file.FileDescriptorProto, message.DescriptorProto) { + panic(fmt.Sprintf("unsafe_unmarshaler and unmarshaler enabled for %v", ccTypeName)) + } + } + if message.DescriptorProto.GetOptions().GetMapEntry() { + continue + } + p.atleastOne = true + + // build a map required field_id -> bitmask offset + rfMap := make(map[int32]uint) + rfNextId := uint(0) + for _, field := range message.Field { + if field.IsRequired() { + rfMap[field.GetNumber()] = rfNextId + rfNextId++ + } + } + rfCount := len(rfMap) + + p.P(`func (m *`, ccTypeName, `) Unmarshal(data []byte) error {`) + p.In() + if rfCount > 0 { + p.P(`var hasFields [`, strconv.Itoa(1+(rfCount-1)/64), `]uint64`) + } + p.P(`l := len(data)`) + p.P(`iNdEx := 0`) + p.P(`for iNdEx < l {`) + p.In() + p.P(`preIndex := iNdEx`) + p.P(`var wire uint64`) + p.decodeVarint("wire", "uint64") + p.P(`fieldNum := int32(wire >> 3)`) + if len(message.Field) > 0 || !message.IsGroup() { + p.P(`wireType := int(wire & 0x7)`) + } + if !message.IsGroup() { + p.P(`if wireType == `, strconv.Itoa(proto.WireEndGroup), ` {`) + p.In() + p.P(`return `, fmtPkg.Use(), `.Errorf("proto: `+message.GetName()+`: wiretype end group for non-group")`) + p.Out() + p.P(`}`) + } + p.P(`if fieldNum <= 0 {`) + p.In() + p.P(`return `, fmtPkg.Use(), `.Errorf("proto: `+message.GetName()+`: illegal tag %d (wire type %d)", fieldNum, wire)`) + p.Out() + p.P(`}`) + p.P(`switch fieldNum {`) + p.In() + for _, field := range message.Field { + fieldname := p.GetFieldName(message, field) + errFieldname := fieldname + if field.OneofIndex != nil { + errFieldname = p.GetOneOfFieldName(message, field) + } + packed := field.IsPacked() + p.P(`case `, strconv.Itoa(int(field.GetNumber())), `:`) + p.In() + wireType := field.WireType() + if packed { + p.P(`if wireType == `, strconv.Itoa(proto.WireBytes), `{`) + p.In() + p.P(`var packedLen int`) + p.decodeVarint("packedLen", "int") + p.P(`if packedLen < 0 {`) + p.In() + p.P(`return ErrInvalidLength` + p.localName) + p.Out() + p.P(`}`) + p.P(`postIndex := iNdEx + packedLen`) + p.P(`if postIndex > l {`) + p.In() + p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`) + p.Out() + p.P(`}`) + p.P(`for iNdEx < postIndex {`) + p.In() + p.field(file.FileDescriptorProto, message, field, fieldname, false) + p.Out() + p.P(`}`) + p.Out() + p.P(`} else if wireType == `, strconv.Itoa(wireType), `{`) + p.In() + p.field(file.FileDescriptorProto, message, field, fieldname, false) + p.Out() + p.P(`} else {`) + p.In() + p.P(`return ` + fmtPkg.Use() + `.Errorf("proto: wrong wireType = %d for field ` + errFieldname + `", wireType)`) + p.Out() + p.P(`}`) + } else { + p.P(`if wireType != `, strconv.Itoa(wireType), `{`) + p.In() + p.P(`return ` + fmtPkg.Use() + `.Errorf("proto: wrong wireType = %d for field ` + errFieldname + `", wireType)`) + p.Out() + p.P(`}`) + p.field(file.FileDescriptorProto, message, field, fieldname, proto3) + } + + if field.IsRequired() { + fieldBit, ok := rfMap[field.GetNumber()] + if !ok { + panic("field is required, but no bit registered") + } + p.P(`hasFields[`, strconv.Itoa(int(fieldBit/64)), `] |= uint64(`, fmt.Sprintf("0x%08x", 1<<(fieldBit%64)), `)`) + } + } + p.Out() + p.P(`default:`) + p.In() + if message.DescriptorProto.HasExtension() { + c := []string{} + for _, erange := range message.GetExtensionRange() { + c = append(c, `((fieldNum >= `+strconv.Itoa(int(erange.GetStart()))+") && (fieldNum<"+strconv.Itoa(int(erange.GetEnd()))+`))`) + } + p.P(`if `, strings.Join(c, "||"), `{`) + p.In() + p.P(`var sizeOfWire int`) + p.P(`for {`) + p.In() + p.P(`sizeOfWire++`) + p.P(`wire >>= 7`) + p.P(`if wire == 0 {`) + p.In() + p.P(`break`) + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + p.P(`iNdEx-=sizeOfWire`) + p.P(`skippy, err := skip`, p.localName+`(data[iNdEx:])`) + p.P(`if err != nil {`) + p.In() + p.P(`return err`) + p.Out() + p.P(`}`) + p.P(`if skippy < 0 {`) + p.In() + p.P(`return ErrInvalidLength`, p.localName) + p.Out() + p.P(`}`) + p.P(`if (iNdEx + skippy) > l {`) + p.In() + p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`) + p.Out() + p.P(`}`) + if gogoproto.HasExtensionsMap(file.FileDescriptorProto, message.DescriptorProto) { + p.P(`if m.XXX_extensions == nil {`) + p.In() + p.P(`m.XXX_extensions = make(map[int32]`, protoPkg.Use(), `.Extension)`) + p.Out() + p.P(`}`) + p.P(`m.XXX_extensions[int32(fieldNum)] = `, protoPkg.Use(), `.NewExtension(data[iNdEx:iNdEx+skippy])`) + } else { + p.P(`m.XXX_extensions = append(m.XXX_extensions, data[iNdEx:iNdEx+skippy]...)`) + } + p.P(`iNdEx += skippy`) + p.Out() + p.P(`} else {`) + p.In() + } + p.P(`iNdEx=preIndex`) + p.P(`skippy, err := skip`, p.localName, `(data[iNdEx:])`) + p.P(`if err != nil {`) + p.In() + p.P(`return err`) + p.Out() + p.P(`}`) + p.P(`if skippy < 0 {`) + p.In() + p.P(`return ErrInvalidLength`, p.localName) + p.Out() + p.P(`}`) + p.P(`if (iNdEx + skippy) > l {`) + p.In() + p.P(`return `, p.ioPkg.Use(), `.ErrUnexpectedEOF`) + p.Out() + p.P(`}`) + if gogoproto.HasUnrecognized(file.FileDescriptorProto, message.DescriptorProto) { + p.P(`m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...)`) + } + p.P(`iNdEx += skippy`) + p.Out() + if message.DescriptorProto.HasExtension() { + p.Out() + p.P(`}`) + } + p.Out() + p.P(`}`) + p.Out() + p.P(`}`) + + for _, field := range message.Field { + if !field.IsRequired() { + continue + } + + fieldBit, ok := rfMap[field.GetNumber()] + if !ok { + panic("field is required, but no bit registered") + } + + p.P(`if hasFields[`, strconv.Itoa(int(fieldBit/64)), `] & uint64(`, fmt.Sprintf("0x%08x", 1<<(fieldBit%64)), `) == 0 {`) + p.In() + if !gogoproto.ImportsGoGoProto(file.FileDescriptorProto) { + p.P(`return new(`, protoPkg.Use(), `.RequiredNotSetError)`) + } else { + p.P(`return `, protoPkg.Use(), `.NewRequiredNotSetError("`, field.GetName(), `")`) + } + p.Out() + p.P(`}`) + } + p.P() + p.P(`if iNdEx > l {`) + p.In() + p.P(`return ` + p.ioPkg.Use() + `.ErrUnexpectedEOF`) + p.Out() + p.P(`}`) + p.P(`return nil`) + p.Out() + p.P(`}`) + } + if !p.atleastOne { + return + } + + p.P(`func skip` + p.localName + `(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflow` + p.localName + ` + } + if iNdEx >= l { + return 0, ` + p.ioPkg.Use() + `.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflow` + p.localName + ` + } + if iNdEx >= l { + return 0, ` + p.ioPkg.Use() + `.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflow` + p.localName + ` + } + if iNdEx >= l { + return 0, ` + p.ioPkg.Use() + `.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLength` + p.localName + ` + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflow` + p.localName + ` + } + if iNdEx >= l { + return 0, ` + p.ioPkg.Use() + `.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skip` + p.localName + `(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, ` + fmtPkg.Use() + `.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") + } + + var ( + ErrInvalidLength` + p.localName + ` = ` + fmtPkg.Use() + `.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflow` + p.localName + ` = ` + fmtPkg.Use() + `.Errorf("proto: integer overflow") + ) + `) +} + +func init() { + generator.RegisterPlugin(NewUnmarshal()) + generator.RegisterPlugin(NewUnsafeUnmarshal()) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..23a6b173440885c96adfeb78ba340f56944ecd37 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/Makefile @@ -0,0 +1,43 @@ +# Go support for Protocol Buffers - Google's data interchange format +# +# Copyright 2010 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. + +install: + go install + +test: install generate-test-pbs + go test + + +generate-test-pbs: + make install + make -C testdata + protoc-min-version --version="3.0.0" --proto_path=.:../../../../ --gogo_out=. proto3_proto/proto3.proto + make diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/all_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/all_test.go new file mode 100644 index 0000000000000000000000000000000000000000..f910bed6beaa0913dcd0718463bf6a8afaafa310 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/all_test.go @@ -0,0 +1,2169 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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 proto_test + +import ( + "bytes" + "encoding/json" + "errors" + "fmt" + "math" + "math/rand" + "reflect" + "runtime/debug" + "strings" + "testing" + "time" + + . "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + . "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata" +) + +var globalO *Buffer + +func old() *Buffer { + if globalO == nil { + globalO = NewBuffer(nil) + } + globalO.Reset() + return globalO +} + +func equalbytes(b1, b2 []byte, t *testing.T) { + if len(b1) != len(b2) { + t.Errorf("wrong lengths: 2*%d != %d", len(b1), len(b2)) + return + } + for i := 0; i < len(b1); i++ { + if b1[i] != b2[i] { + t.Errorf("bad byte[%d]:%x %x: %s %s", i, b1[i], b2[i], b1, b2) + } + } +} + +func initGoTestField() *GoTestField { + f := new(GoTestField) + f.Label = String("label") + f.Type = String("type") + return f +} + +// These are all structurally equivalent but the tag numbers differ. +// (It's remarkable that required, optional, and repeated all have +// 8 letters.) +func initGoTest_RequiredGroup() *GoTest_RequiredGroup { + return &GoTest_RequiredGroup{ + RequiredField: String("required"), + } +} + +func initGoTest_OptionalGroup() *GoTest_OptionalGroup { + return &GoTest_OptionalGroup{ + RequiredField: String("optional"), + } +} + +func initGoTest_RepeatedGroup() *GoTest_RepeatedGroup { + return &GoTest_RepeatedGroup{ + RequiredField: String("repeated"), + } +} + +func initGoTest(setdefaults bool) *GoTest { + pb := new(GoTest) + if setdefaults { + pb.F_BoolDefaulted = Bool(Default_GoTest_F_BoolDefaulted) + pb.F_Int32Defaulted = Int32(Default_GoTest_F_Int32Defaulted) + pb.F_Int64Defaulted = Int64(Default_GoTest_F_Int64Defaulted) + pb.F_Fixed32Defaulted = Uint32(Default_GoTest_F_Fixed32Defaulted) + pb.F_Fixed64Defaulted = Uint64(Default_GoTest_F_Fixed64Defaulted) + pb.F_Uint32Defaulted = Uint32(Default_GoTest_F_Uint32Defaulted) + pb.F_Uint64Defaulted = Uint64(Default_GoTest_F_Uint64Defaulted) + pb.F_FloatDefaulted = Float32(Default_GoTest_F_FloatDefaulted) + pb.F_DoubleDefaulted = Float64(Default_GoTest_F_DoubleDefaulted) + pb.F_StringDefaulted = String(Default_GoTest_F_StringDefaulted) + pb.F_BytesDefaulted = Default_GoTest_F_BytesDefaulted + pb.F_Sint32Defaulted = Int32(Default_GoTest_F_Sint32Defaulted) + pb.F_Sint64Defaulted = Int64(Default_GoTest_F_Sint64Defaulted) + } + + pb.Kind = GoTest_TIME.Enum() + pb.RequiredField = initGoTestField() + pb.F_BoolRequired = Bool(true) + pb.F_Int32Required = Int32(3) + pb.F_Int64Required = Int64(6) + pb.F_Fixed32Required = Uint32(32) + pb.F_Fixed64Required = Uint64(64) + pb.F_Uint32Required = Uint32(3232) + pb.F_Uint64Required = Uint64(6464) + pb.F_FloatRequired = Float32(3232) + pb.F_DoubleRequired = Float64(6464) + pb.F_StringRequired = String("string") + pb.F_BytesRequired = []byte("bytes") + pb.F_Sint32Required = Int32(-32) + pb.F_Sint64Required = Int64(-64) + pb.Requiredgroup = initGoTest_RequiredGroup() + + return pb +} + +func fail(msg string, b *bytes.Buffer, s string, t *testing.T) { + data := b.Bytes() + ld := len(data) + ls := len(s) / 2 + + fmt.Printf("fail %s ld=%d ls=%d\n", msg, ld, ls) + + // find the interesting spot - n + n := ls + if ld < ls { + n = ld + } + j := 0 + for i := 0; i < n; i++ { + bs := hex(s[j])*16 + hex(s[j+1]) + j += 2 + if data[i] == bs { + continue + } + n = i + break + } + l := n - 10 + if l < 0 { + l = 0 + } + h := n + 10 + + // find the interesting spot - n + fmt.Printf("is[%d]:", l) + for i := l; i < h; i++ { + if i >= ld { + fmt.Printf(" --") + continue + } + fmt.Printf(" %.2x", data[i]) + } + fmt.Printf("\n") + + fmt.Printf("sb[%d]:", l) + for i := l; i < h; i++ { + if i >= ls { + fmt.Printf(" --") + continue + } + bs := hex(s[j])*16 + hex(s[j+1]) + j += 2 + fmt.Printf(" %.2x", bs) + } + fmt.Printf("\n") + + t.Fail() + + // t.Errorf("%s: \ngood: %s\nbad: %x", msg, s, b.Bytes()) + // Print the output in a partially-decoded format; can + // be helpful when updating the test. It produces the output + // that is pasted, with minor edits, into the argument to verify(). + // data := b.Bytes() + // nesting := 0 + // for b.Len() > 0 { + // start := len(data) - b.Len() + // var u uint64 + // u, err := DecodeVarint(b) + // if err != nil { + // fmt.Printf("decode error on varint:", err) + // return + // } + // wire := u & 0x7 + // tag := u >> 3 + // switch wire { + // case WireVarint: + // v, err := DecodeVarint(b) + // if err != nil { + // fmt.Printf("decode error on varint:", err) + // return + // } + // fmt.Printf("\t\t\"%x\" // field %d, encoding %d, value %d\n", + // data[start:len(data)-b.Len()], tag, wire, v) + // case WireFixed32: + // v, err := DecodeFixed32(b) + // if err != nil { + // fmt.Printf("decode error on fixed32:", err) + // return + // } + // fmt.Printf("\t\t\"%x\" // field %d, encoding %d, value %d\n", + // data[start:len(data)-b.Len()], tag, wire, v) + // case WireFixed64: + // v, err := DecodeFixed64(b) + // if err != nil { + // fmt.Printf("decode error on fixed64:", err) + // return + // } + // fmt.Printf("\t\t\"%x\" // field %d, encoding %d, value %d\n", + // data[start:len(data)-b.Len()], tag, wire, v) + // case WireBytes: + // nb, err := DecodeVarint(b) + // if err != nil { + // fmt.Printf("decode error on bytes:", err) + // return + // } + // after_tag := len(data) - b.Len() + // str := make([]byte, nb) + // _, err = b.Read(str) + // if err != nil { + // fmt.Printf("decode error on bytes:", err) + // return + // } + // fmt.Printf("\t\t\"%x\" \"%x\" // field %d, encoding %d (FIELD)\n", + // data[start:after_tag], str, tag, wire) + // case WireStartGroup: + // nesting++ + // fmt.Printf("\t\t\"%x\"\t\t// start group field %d level %d\n", + // data[start:len(data)-b.Len()], tag, nesting) + // case WireEndGroup: + // fmt.Printf("\t\t\"%x\"\t\t// end group field %d level %d\n", + // data[start:len(data)-b.Len()], tag, nesting) + // nesting-- + // default: + // fmt.Printf("unrecognized wire type %d\n", wire) + // return + // } + // } +} + +func hex(c uint8) uint8 { + if '0' <= c && c <= '9' { + return c - '0' + } + if 'a' <= c && c <= 'f' { + return 10 + c - 'a' + } + if 'A' <= c && c <= 'F' { + return 10 + c - 'A' + } + return 0 +} + +func equal(b []byte, s string, t *testing.T) bool { + if 2*len(b) != len(s) { + // fail(fmt.Sprintf("wrong lengths: 2*%d != %d", len(b), len(s)), b, s, t) + fmt.Printf("wrong lengths: 2*%d != %d\n", len(b), len(s)) + return false + } + for i, j := 0, 0; i < len(b); i, j = i+1, j+2 { + x := hex(s[j])*16 + hex(s[j+1]) + if b[i] != x { + // fail(fmt.Sprintf("bad byte[%d]:%x %x", i, b[i], x), b, s, t) + fmt.Printf("bad byte[%d]:%x %x", i, b[i], x) + return false + } + } + return true +} + +func overify(t *testing.T, pb *GoTest, expected string) { + o := old() + err := o.Marshal(pb) + if err != nil { + fmt.Printf("overify marshal-1 err = %v", err) + o.DebugPrint("", o.Bytes()) + t.Fatalf("expected = %s", expected) + } + if !equal(o.Bytes(), expected, t) { + o.DebugPrint("overify neq 1", o.Bytes()) + t.Fatalf("expected = %s", expected) + } + + // Now test Unmarshal by recreating the original buffer. + pbd := new(GoTest) + err = o.Unmarshal(pbd) + if err != nil { + t.Fatalf("overify unmarshal err = %v", err) + o.DebugPrint("", o.Bytes()) + t.Fatalf("string = %s", expected) + } + o.Reset() + err = o.Marshal(pbd) + if err != nil { + t.Errorf("overify marshal-2 err = %v", err) + o.DebugPrint("", o.Bytes()) + t.Fatalf("string = %s", expected) + } + if !equal(o.Bytes(), expected, t) { + o.DebugPrint("overify neq 2", o.Bytes()) + t.Fatalf("string = %s", expected) + } +} + +// Simple tests for numeric encode/decode primitives (varint, etc.) +func TestNumericPrimitives(t *testing.T) { + for i := uint64(0); i < 1e6; i += 111 { + o := old() + if o.EncodeVarint(i) != nil { + t.Error("EncodeVarint") + break + } + x, e := o.DecodeVarint() + if e != nil { + t.Fatal("DecodeVarint") + } + if x != i { + t.Fatal("varint decode fail:", i, x) + } + + o = old() + if o.EncodeFixed32(i) != nil { + t.Fatal("encFixed32") + } + x, e = o.DecodeFixed32() + if e != nil { + t.Fatal("decFixed32") + } + if x != i { + t.Fatal("fixed32 decode fail:", i, x) + } + + o = old() + if o.EncodeFixed64(i*1234567) != nil { + t.Error("encFixed64") + break + } + x, e = o.DecodeFixed64() + if e != nil { + t.Error("decFixed64") + break + } + if x != i*1234567 { + t.Error("fixed64 decode fail:", i*1234567, x) + break + } + + o = old() + i32 := int32(i - 12345) + if o.EncodeZigzag32(uint64(i32)) != nil { + t.Fatal("EncodeZigzag32") + } + x, e = o.DecodeZigzag32() + if e != nil { + t.Fatal("DecodeZigzag32") + } + if x != uint64(uint32(i32)) { + t.Fatal("zigzag32 decode fail:", i32, x) + } + + o = old() + i64 := int64(i - 12345) + if o.EncodeZigzag64(uint64(i64)) != nil { + t.Fatal("EncodeZigzag64") + } + x, e = o.DecodeZigzag64() + if e != nil { + t.Fatal("DecodeZigzag64") + } + if x != uint64(i64) { + t.Fatal("zigzag64 decode fail:", i64, x) + } + } +} + +// fakeMarshaler is a simple struct implementing Marshaler and Message interfaces. +type fakeMarshaler struct { + b []byte + err error +} + +func (f *fakeMarshaler) Marshal() ([]byte, error) { return f.b, f.err } +func (f *fakeMarshaler) String() string { return fmt.Sprintf("Bytes: %v Error: %v", f.b, f.err) } +func (f *fakeMarshaler) ProtoMessage() {} +func (f *fakeMarshaler) Reset() {} + +type msgWithFakeMarshaler struct { + M *fakeMarshaler `protobuf:"bytes,1,opt,name=fake"` +} + +func (m *msgWithFakeMarshaler) String() string { return CompactTextString(m) } +func (m *msgWithFakeMarshaler) ProtoMessage() {} +func (m *msgWithFakeMarshaler) Reset() {} + +// Simple tests for proto messages that implement the Marshaler interface. +func TestMarshalerEncoding(t *testing.T) { + tests := []struct { + name string + m Message + want []byte + wantErr error + }{ + { + name: "Marshaler that fails", + m: &fakeMarshaler{ + err: errors.New("some marshal err"), + b: []byte{5, 6, 7}, + }, + // Since there's an error, nothing should be written to buffer. + want: nil, + wantErr: errors.New("some marshal err"), + }, + { + name: "Marshaler that fails with RequiredNotSetError", + m: &msgWithFakeMarshaler{ + M: &fakeMarshaler{ + err: &RequiredNotSetError{}, + b: []byte{5, 6, 7}, + }, + }, + // Since there's an error that can be continued after, + // the buffer should be written. + want: []byte{ + 10, 3, // for &msgWithFakeMarshaler + 5, 6, 7, // for &fakeMarshaler + }, + wantErr: &RequiredNotSetError{}, + }, + { + name: "Marshaler that succeeds", + m: &fakeMarshaler{ + b: []byte{0, 1, 2, 3, 4, 127, 255}, + }, + want: []byte{0, 1, 2, 3, 4, 127, 255}, + wantErr: nil, + }, + } + for _, test := range tests { + b := NewBuffer(nil) + err := b.Marshal(test.m) + if _, ok := err.(*RequiredNotSetError); ok { + // We're not in package proto, so we can only assert the type in this case. + err = &RequiredNotSetError{} + } + if !reflect.DeepEqual(test.wantErr, err) { + t.Errorf("%s: got err %v wanted %v", test.name, err, test.wantErr) + } + if !reflect.DeepEqual(test.want, b.Bytes()) { + t.Errorf("%s: got bytes %v wanted %v", test.name, b.Bytes(), test.want) + } + } +} + +// Simple tests for bytes +func TestBytesPrimitives(t *testing.T) { + o := old() + bytes := []byte{'n', 'o', 'w', ' ', 'i', 's', ' ', 't', 'h', 'e', ' ', 't', 'i', 'm', 'e'} + if o.EncodeRawBytes(bytes) != nil { + t.Error("EncodeRawBytes") + } + decb, e := o.DecodeRawBytes(false) + if e != nil { + t.Error("DecodeRawBytes") + } + equalbytes(bytes, decb, t) +} + +// Simple tests for strings +func TestStringPrimitives(t *testing.T) { + o := old() + s := "now is the time" + if o.EncodeStringBytes(s) != nil { + t.Error("enc_string") + } + decs, e := o.DecodeStringBytes() + if e != nil { + t.Error("dec_string") + } + if s != decs { + t.Error("string encode/decode fail:", s, decs) + } +} + +// Do we catch the "required bit not set" case? +func TestRequiredBit(t *testing.T) { + o := old() + pb := new(GoTest) + err := o.Marshal(pb) + if err == nil { + t.Error("did not catch missing required fields") + } else if strings.Index(err.Error(), "Kind") < 0 { + t.Error("wrong error type:", err) + } +} + +// Check that all fields are nil. +// Clearly silly, and a residue from a more interesting test with an earlier, +// different initialization property, but it once caught a compiler bug so +// it lives. +func checkInitialized(pb *GoTest, t *testing.T) { + if pb.F_BoolDefaulted != nil { + t.Error("New or Reset did not set boolean:", *pb.F_BoolDefaulted) + } + if pb.F_Int32Defaulted != nil { + t.Error("New or Reset did not set int32:", *pb.F_Int32Defaulted) + } + if pb.F_Int64Defaulted != nil { + t.Error("New or Reset did not set int64:", *pb.F_Int64Defaulted) + } + if pb.F_Fixed32Defaulted != nil { + t.Error("New or Reset did not set fixed32:", *pb.F_Fixed32Defaulted) + } + if pb.F_Fixed64Defaulted != nil { + t.Error("New or Reset did not set fixed64:", *pb.F_Fixed64Defaulted) + } + if pb.F_Uint32Defaulted != nil { + t.Error("New or Reset did not set uint32:", *pb.F_Uint32Defaulted) + } + if pb.F_Uint64Defaulted != nil { + t.Error("New or Reset did not set uint64:", *pb.F_Uint64Defaulted) + } + if pb.F_FloatDefaulted != nil { + t.Error("New or Reset did not set float:", *pb.F_FloatDefaulted) + } + if pb.F_DoubleDefaulted != nil { + t.Error("New or Reset did not set double:", *pb.F_DoubleDefaulted) + } + if pb.F_StringDefaulted != nil { + t.Error("New or Reset did not set string:", *pb.F_StringDefaulted) + } + if pb.F_BytesDefaulted != nil { + t.Error("New or Reset did not set bytes:", string(pb.F_BytesDefaulted)) + } + if pb.F_Sint32Defaulted != nil { + t.Error("New or Reset did not set int32:", *pb.F_Sint32Defaulted) + } + if pb.F_Sint64Defaulted != nil { + t.Error("New or Reset did not set int64:", *pb.F_Sint64Defaulted) + } +} + +// Does Reset() reset? +func TestReset(t *testing.T) { + pb := initGoTest(true) + // muck with some values + pb.F_BoolDefaulted = Bool(false) + pb.F_Int32Defaulted = Int32(237) + pb.F_Int64Defaulted = Int64(12346) + pb.F_Fixed32Defaulted = Uint32(32000) + pb.F_Fixed64Defaulted = Uint64(666) + pb.F_Uint32Defaulted = Uint32(323232) + pb.F_Uint64Defaulted = nil + pb.F_FloatDefaulted = nil + pb.F_DoubleDefaulted = Float64(0) + pb.F_StringDefaulted = String("gotcha") + pb.F_BytesDefaulted = []byte("asdfasdf") + pb.F_Sint32Defaulted = Int32(123) + pb.F_Sint64Defaulted = Int64(789) + pb.Reset() + checkInitialized(pb, t) +} + +// All required fields set, no defaults provided. +func TestEncodeDecode1(t *testing.T) { + pb := initGoTest(false) + overify(t, pb, + "0807"+ // field 1, encoding 0, value 7 + "220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField) + "5001"+ // field 10, encoding 0, value 1 + "5803"+ // field 11, encoding 0, value 3 + "6006"+ // field 12, encoding 0, value 6 + "6d20000000"+ // field 13, encoding 5, value 0x20 + "714000000000000000"+ // field 14, encoding 1, value 0x40 + "78a019"+ // field 15, encoding 0, value 0xca0 = 3232 + "8001c032"+ // field 16, encoding 0, value 0x1940 = 6464 + "8d0100004a45"+ // field 17, encoding 5, value 3232.0 + "9101000000000040b940"+ // field 18, encoding 1, value 6464.0 + "9a0106"+"737472696e67"+ // field 19, encoding 2, string "string" + "b304"+ // field 70, encoding 3, start group + "ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required" + "b404"+ // field 70, encoding 4, end group + "aa0605"+"6279746573"+ // field 101, encoding 2, string "bytes" + "b0063f"+ // field 102, encoding 0, 0x3f zigzag32 + "b8067f") // field 103, encoding 0, 0x7f zigzag64 +} + +// All required fields set, defaults provided. +func TestEncodeDecode2(t *testing.T) { + pb := initGoTest(true) + overify(t, pb, + "0807"+ // field 1, encoding 0, value 7 + "220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField) + "5001"+ // field 10, encoding 0, value 1 + "5803"+ // field 11, encoding 0, value 3 + "6006"+ // field 12, encoding 0, value 6 + "6d20000000"+ // field 13, encoding 5, value 32 + "714000000000000000"+ // field 14, encoding 1, value 64 + "78a019"+ // field 15, encoding 0, value 3232 + "8001c032"+ // field 16, encoding 0, value 6464 + "8d0100004a45"+ // field 17, encoding 5, value 3232.0 + "9101000000000040b940"+ // field 18, encoding 1, value 6464.0 + "9a0106"+"737472696e67"+ // field 19, encoding 2 string "string" + "c00201"+ // field 40, encoding 0, value 1 + "c80220"+ // field 41, encoding 0, value 32 + "d00240"+ // field 42, encoding 0, value 64 + "dd0240010000"+ // field 43, encoding 5, value 320 + "e1028002000000000000"+ // field 44, encoding 1, value 640 + "e8028019"+ // field 45, encoding 0, value 3200 + "f0028032"+ // field 46, encoding 0, value 6400 + "fd02e0659948"+ // field 47, encoding 5, value 314159.0 + "81030000000050971041"+ // field 48, encoding 1, value 271828.0 + "8a0310"+"68656c6c6f2c2022776f726c6421220a"+ // field 49, encoding 2 string "hello, \"world!\"\n" + "b304"+ // start group field 70 level 1 + "ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required" + "b404"+ // end group field 70 level 1 + "aa0605"+"6279746573"+ // field 101, encoding 2 string "bytes" + "b0063f"+ // field 102, encoding 0, 0x3f zigzag32 + "b8067f"+ // field 103, encoding 0, 0x7f zigzag64 + "8a1907"+"4269676e6f7365"+ // field 401, encoding 2, string "Bignose" + "90193f"+ // field 402, encoding 0, value 63 + "98197f") // field 403, encoding 0, value 127 + +} + +// All default fields set to their default value by hand +func TestEncodeDecode3(t *testing.T) { + pb := initGoTest(false) + pb.F_BoolDefaulted = Bool(true) + pb.F_Int32Defaulted = Int32(32) + pb.F_Int64Defaulted = Int64(64) + pb.F_Fixed32Defaulted = Uint32(320) + pb.F_Fixed64Defaulted = Uint64(640) + pb.F_Uint32Defaulted = Uint32(3200) + pb.F_Uint64Defaulted = Uint64(6400) + pb.F_FloatDefaulted = Float32(314159) + pb.F_DoubleDefaulted = Float64(271828) + pb.F_StringDefaulted = String("hello, \"world!\"\n") + pb.F_BytesDefaulted = []byte("Bignose") + pb.F_Sint32Defaulted = Int32(-32) + pb.F_Sint64Defaulted = Int64(-64) + + overify(t, pb, + "0807"+ // field 1, encoding 0, value 7 + "220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField) + "5001"+ // field 10, encoding 0, value 1 + "5803"+ // field 11, encoding 0, value 3 + "6006"+ // field 12, encoding 0, value 6 + "6d20000000"+ // field 13, encoding 5, value 32 + "714000000000000000"+ // field 14, encoding 1, value 64 + "78a019"+ // field 15, encoding 0, value 3232 + "8001c032"+ // field 16, encoding 0, value 6464 + "8d0100004a45"+ // field 17, encoding 5, value 3232.0 + "9101000000000040b940"+ // field 18, encoding 1, value 6464.0 + "9a0106"+"737472696e67"+ // field 19, encoding 2 string "string" + "c00201"+ // field 40, encoding 0, value 1 + "c80220"+ // field 41, encoding 0, value 32 + "d00240"+ // field 42, encoding 0, value 64 + "dd0240010000"+ // field 43, encoding 5, value 320 + "e1028002000000000000"+ // field 44, encoding 1, value 640 + "e8028019"+ // field 45, encoding 0, value 3200 + "f0028032"+ // field 46, encoding 0, value 6400 + "fd02e0659948"+ // field 47, encoding 5, value 314159.0 + "81030000000050971041"+ // field 48, encoding 1, value 271828.0 + "8a0310"+"68656c6c6f2c2022776f726c6421220a"+ // field 49, encoding 2 string "hello, \"world!\"\n" + "b304"+ // start group field 70 level 1 + "ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required" + "b404"+ // end group field 70 level 1 + "aa0605"+"6279746573"+ // field 101, encoding 2 string "bytes" + "b0063f"+ // field 102, encoding 0, 0x3f zigzag32 + "b8067f"+ // field 103, encoding 0, 0x7f zigzag64 + "8a1907"+"4269676e6f7365"+ // field 401, encoding 2, string "Bignose" + "90193f"+ // field 402, encoding 0, value 63 + "98197f") // field 403, encoding 0, value 127 + +} + +// All required fields set, defaults provided, all non-defaulted optional fields have values. +func TestEncodeDecode4(t *testing.T) { + pb := initGoTest(true) + pb.Table = String("hello") + pb.Param = Int32(7) + pb.OptionalField = initGoTestField() + pb.F_BoolOptional = Bool(true) + pb.F_Int32Optional = Int32(32) + pb.F_Int64Optional = Int64(64) + pb.F_Fixed32Optional = Uint32(3232) + pb.F_Fixed64Optional = Uint64(6464) + pb.F_Uint32Optional = Uint32(323232) + pb.F_Uint64Optional = Uint64(646464) + pb.F_FloatOptional = Float32(32.) + pb.F_DoubleOptional = Float64(64.) + pb.F_StringOptional = String("hello") + pb.F_BytesOptional = []byte("Bignose") + pb.F_Sint32Optional = Int32(-32) + pb.F_Sint64Optional = Int64(-64) + pb.Optionalgroup = initGoTest_OptionalGroup() + + overify(t, pb, + "0807"+ // field 1, encoding 0, value 7 + "1205"+"68656c6c6f"+ // field 2, encoding 2, string "hello" + "1807"+ // field 3, encoding 0, value 7 + "220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField) + "320d"+"0a056c6162656c120474797065"+ // field 6, encoding 2 (GoTestField) + "5001"+ // field 10, encoding 0, value 1 + "5803"+ // field 11, encoding 0, value 3 + "6006"+ // field 12, encoding 0, value 6 + "6d20000000"+ // field 13, encoding 5, value 32 + "714000000000000000"+ // field 14, encoding 1, value 64 + "78a019"+ // field 15, encoding 0, value 3232 + "8001c032"+ // field 16, encoding 0, value 6464 + "8d0100004a45"+ // field 17, encoding 5, value 3232.0 + "9101000000000040b940"+ // field 18, encoding 1, value 6464.0 + "9a0106"+"737472696e67"+ // field 19, encoding 2 string "string" + "f00101"+ // field 30, encoding 0, value 1 + "f80120"+ // field 31, encoding 0, value 32 + "800240"+ // field 32, encoding 0, value 64 + "8d02a00c0000"+ // field 33, encoding 5, value 3232 + "91024019000000000000"+ // field 34, encoding 1, value 6464 + "9802a0dd13"+ // field 35, encoding 0, value 323232 + "a002c0ba27"+ // field 36, encoding 0, value 646464 + "ad0200000042"+ // field 37, encoding 5, value 32.0 + "b1020000000000005040"+ // field 38, encoding 1, value 64.0 + "ba0205"+"68656c6c6f"+ // field 39, encoding 2, string "hello" + "c00201"+ // field 40, encoding 0, value 1 + "c80220"+ // field 41, encoding 0, value 32 + "d00240"+ // field 42, encoding 0, value 64 + "dd0240010000"+ // field 43, encoding 5, value 320 + "e1028002000000000000"+ // field 44, encoding 1, value 640 + "e8028019"+ // field 45, encoding 0, value 3200 + "f0028032"+ // field 46, encoding 0, value 6400 + "fd02e0659948"+ // field 47, encoding 5, value 314159.0 + "81030000000050971041"+ // field 48, encoding 1, value 271828.0 + "8a0310"+"68656c6c6f2c2022776f726c6421220a"+ // field 49, encoding 2 string "hello, \"world!\"\n" + "b304"+ // start group field 70 level 1 + "ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required" + "b404"+ // end group field 70 level 1 + "d305"+ // start group field 90 level 1 + "da0508"+"6f7074696f6e616c"+ // field 91, encoding 2, string "optional" + "d405"+ // end group field 90 level 1 + "aa0605"+"6279746573"+ // field 101, encoding 2 string "bytes" + "b0063f"+ // field 102, encoding 0, 0x3f zigzag32 + "b8067f"+ // field 103, encoding 0, 0x7f zigzag64 + "ea1207"+"4269676e6f7365"+ // field 301, encoding 2, string "Bignose" + "f0123f"+ // field 302, encoding 0, value 63 + "f8127f"+ // field 303, encoding 0, value 127 + "8a1907"+"4269676e6f7365"+ // field 401, encoding 2, string "Bignose" + "90193f"+ // field 402, encoding 0, value 63 + "98197f") // field 403, encoding 0, value 127 + +} + +// All required fields set, defaults provided, all repeated fields given two values. +func TestEncodeDecode5(t *testing.T) { + pb := initGoTest(true) + pb.RepeatedField = []*GoTestField{initGoTestField(), initGoTestField()} + pb.F_BoolRepeated = []bool{false, true} + pb.F_Int32Repeated = []int32{32, 33} + pb.F_Int64Repeated = []int64{64, 65} + pb.F_Fixed32Repeated = []uint32{3232, 3333} + pb.F_Fixed64Repeated = []uint64{6464, 6565} + pb.F_Uint32Repeated = []uint32{323232, 333333} + pb.F_Uint64Repeated = []uint64{646464, 656565} + pb.F_FloatRepeated = []float32{32., 33.} + pb.F_DoubleRepeated = []float64{64., 65.} + pb.F_StringRepeated = []string{"hello", "sailor"} + pb.F_BytesRepeated = [][]byte{[]byte("big"), []byte("nose")} + pb.F_Sint32Repeated = []int32{32, -32} + pb.F_Sint64Repeated = []int64{64, -64} + pb.Repeatedgroup = []*GoTest_RepeatedGroup{initGoTest_RepeatedGroup(), initGoTest_RepeatedGroup()} + + overify(t, pb, + "0807"+ // field 1, encoding 0, value 7 + "220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField) + "2a0d"+"0a056c6162656c120474797065"+ // field 5, encoding 2 (GoTestField) + "2a0d"+"0a056c6162656c120474797065"+ // field 5, encoding 2 (GoTestField) + "5001"+ // field 10, encoding 0, value 1 + "5803"+ // field 11, encoding 0, value 3 + "6006"+ // field 12, encoding 0, value 6 + "6d20000000"+ // field 13, encoding 5, value 32 + "714000000000000000"+ // field 14, encoding 1, value 64 + "78a019"+ // field 15, encoding 0, value 3232 + "8001c032"+ // field 16, encoding 0, value 6464 + "8d0100004a45"+ // field 17, encoding 5, value 3232.0 + "9101000000000040b940"+ // field 18, encoding 1, value 6464.0 + "9a0106"+"737472696e67"+ // field 19, encoding 2 string "string" + "a00100"+ // field 20, encoding 0, value 0 + "a00101"+ // field 20, encoding 0, value 1 + "a80120"+ // field 21, encoding 0, value 32 + "a80121"+ // field 21, encoding 0, value 33 + "b00140"+ // field 22, encoding 0, value 64 + "b00141"+ // field 22, encoding 0, value 65 + "bd01a00c0000"+ // field 23, encoding 5, value 3232 + "bd01050d0000"+ // field 23, encoding 5, value 3333 + "c1014019000000000000"+ // field 24, encoding 1, value 6464 + "c101a519000000000000"+ // field 24, encoding 1, value 6565 + "c801a0dd13"+ // field 25, encoding 0, value 323232 + "c80195ac14"+ // field 25, encoding 0, value 333333 + "d001c0ba27"+ // field 26, encoding 0, value 646464 + "d001b58928"+ // field 26, encoding 0, value 656565 + "dd0100000042"+ // field 27, encoding 5, value 32.0 + "dd0100000442"+ // field 27, encoding 5, value 33.0 + "e1010000000000005040"+ // field 28, encoding 1, value 64.0 + "e1010000000000405040"+ // field 28, encoding 1, value 65.0 + "ea0105"+"68656c6c6f"+ // field 29, encoding 2, string "hello" + "ea0106"+"7361696c6f72"+ // field 29, encoding 2, string "sailor" + "c00201"+ // field 40, encoding 0, value 1 + "c80220"+ // field 41, encoding 0, value 32 + "d00240"+ // field 42, encoding 0, value 64 + "dd0240010000"+ // field 43, encoding 5, value 320 + "e1028002000000000000"+ // field 44, encoding 1, value 640 + "e8028019"+ // field 45, encoding 0, value 3200 + "f0028032"+ // field 46, encoding 0, value 6400 + "fd02e0659948"+ // field 47, encoding 5, value 314159.0 + "81030000000050971041"+ // field 48, encoding 1, value 271828.0 + "8a0310"+"68656c6c6f2c2022776f726c6421220a"+ // field 49, encoding 2 string "hello, \"world!\"\n" + "b304"+ // start group field 70 level 1 + "ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required" + "b404"+ // end group field 70 level 1 + "8305"+ // start group field 80 level 1 + "8a0508"+"7265706561746564"+ // field 81, encoding 2, string "repeated" + "8405"+ // end group field 80 level 1 + "8305"+ // start group field 80 level 1 + "8a0508"+"7265706561746564"+ // field 81, encoding 2, string "repeated" + "8405"+ // end group field 80 level 1 + "aa0605"+"6279746573"+ // field 101, encoding 2 string "bytes" + "b0063f"+ // field 102, encoding 0, 0x3f zigzag32 + "b8067f"+ // field 103, encoding 0, 0x7f zigzag64 + "ca0c03"+"626967"+ // field 201, encoding 2, string "big" + "ca0c04"+"6e6f7365"+ // field 201, encoding 2, string "nose" + "d00c40"+ // field 202, encoding 0, value 32 + "d00c3f"+ // field 202, encoding 0, value -32 + "d80c8001"+ // field 203, encoding 0, value 64 + "d80c7f"+ // field 203, encoding 0, value -64 + "8a1907"+"4269676e6f7365"+ // field 401, encoding 2, string "Bignose" + "90193f"+ // field 402, encoding 0, value 63 + "98197f") // field 403, encoding 0, value 127 + +} + +// All required fields set, all packed repeated fields given two values. +func TestEncodeDecode6(t *testing.T) { + pb := initGoTest(false) + pb.F_BoolRepeatedPacked = []bool{false, true} + pb.F_Int32RepeatedPacked = []int32{32, 33} + pb.F_Int64RepeatedPacked = []int64{64, 65} + pb.F_Fixed32RepeatedPacked = []uint32{3232, 3333} + pb.F_Fixed64RepeatedPacked = []uint64{6464, 6565} + pb.F_Uint32RepeatedPacked = []uint32{323232, 333333} + pb.F_Uint64RepeatedPacked = []uint64{646464, 656565} + pb.F_FloatRepeatedPacked = []float32{32., 33.} + pb.F_DoubleRepeatedPacked = []float64{64., 65.} + pb.F_Sint32RepeatedPacked = []int32{32, -32} + pb.F_Sint64RepeatedPacked = []int64{64, -64} + + overify(t, pb, + "0807"+ // field 1, encoding 0, value 7 + "220d"+"0a056c6162656c120474797065"+ // field 4, encoding 2 (GoTestField) + "5001"+ // field 10, encoding 0, value 1 + "5803"+ // field 11, encoding 0, value 3 + "6006"+ // field 12, encoding 0, value 6 + "6d20000000"+ // field 13, encoding 5, value 32 + "714000000000000000"+ // field 14, encoding 1, value 64 + "78a019"+ // field 15, encoding 0, value 3232 + "8001c032"+ // field 16, encoding 0, value 6464 + "8d0100004a45"+ // field 17, encoding 5, value 3232.0 + "9101000000000040b940"+ // field 18, encoding 1, value 6464.0 + "9a0106"+"737472696e67"+ // field 19, encoding 2 string "string" + "9203020001"+ // field 50, encoding 2, 2 bytes, value 0, value 1 + "9a03022021"+ // field 51, encoding 2, 2 bytes, value 32, value 33 + "a203024041"+ // field 52, encoding 2, 2 bytes, value 64, value 65 + "aa0308"+ // field 53, encoding 2, 8 bytes + "a00c0000050d0000"+ // value 3232, value 3333 + "b20310"+ // field 54, encoding 2, 16 bytes + "4019000000000000a519000000000000"+ // value 6464, value 6565 + "ba0306"+ // field 55, encoding 2, 6 bytes + "a0dd1395ac14"+ // value 323232, value 333333 + "c20306"+ // field 56, encoding 2, 6 bytes + "c0ba27b58928"+ // value 646464, value 656565 + "ca0308"+ // field 57, encoding 2, 8 bytes + "0000004200000442"+ // value 32.0, value 33.0 + "d20310"+ // field 58, encoding 2, 16 bytes + "00000000000050400000000000405040"+ // value 64.0, value 65.0 + "b304"+ // start group field 70 level 1 + "ba0408"+"7265717569726564"+ // field 71, encoding 2, string "required" + "b404"+ // end group field 70 level 1 + "aa0605"+"6279746573"+ // field 101, encoding 2 string "bytes" + "b0063f"+ // field 102, encoding 0, 0x3f zigzag32 + "b8067f"+ // field 103, encoding 0, 0x7f zigzag64 + "b21f02"+ // field 502, encoding 2, 2 bytes + "403f"+ // value 32, value -32 + "ba1f03"+ // field 503, encoding 2, 3 bytes + "80017f") // value 64, value -64 +} + +// Test that we can encode empty bytes fields. +func TestEncodeDecodeBytes1(t *testing.T) { + pb := initGoTest(false) + + // Create our bytes + pb.F_BytesRequired = []byte{} + pb.F_BytesRepeated = [][]byte{{}} + pb.F_BytesOptional = []byte{} + + d, err := Marshal(pb) + if err != nil { + t.Error(err) + } + + pbd := new(GoTest) + if err := Unmarshal(d, pbd); err != nil { + t.Error(err) + } + + if pbd.F_BytesRequired == nil || len(pbd.F_BytesRequired) != 0 { + t.Error("required empty bytes field is incorrect") + } + if pbd.F_BytesRepeated == nil || len(pbd.F_BytesRepeated) == 1 && pbd.F_BytesRepeated[0] == nil { + t.Error("repeated empty bytes field is incorrect") + } + if pbd.F_BytesOptional == nil || len(pbd.F_BytesOptional) != 0 { + t.Error("optional empty bytes field is incorrect") + } +} + +// Test that we encode nil-valued fields of a repeated bytes field correctly. +// Since entries in a repeated field cannot be nil, nil must mean empty value. +func TestEncodeDecodeBytes2(t *testing.T) { + pb := initGoTest(false) + + // Create our bytes + pb.F_BytesRepeated = [][]byte{nil} + + d, err := Marshal(pb) + if err != nil { + t.Error(err) + } + + pbd := new(GoTest) + if err := Unmarshal(d, pbd); err != nil { + t.Error(err) + } + + if len(pbd.F_BytesRepeated) != 1 || pbd.F_BytesRepeated[0] == nil { + t.Error("Unexpected value for repeated bytes field") + } +} + +// All required fields set, defaults provided, all repeated fields given two values. +func TestSkippingUnrecognizedFields(t *testing.T) { + o := old() + pb := initGoTestField() + + // Marshal it normally. + o.Marshal(pb) + + // Now new a GoSkipTest record. + skip := &GoSkipTest{ + SkipInt32: Int32(32), + SkipFixed32: Uint32(3232), + SkipFixed64: Uint64(6464), + SkipString: String("skipper"), + Skipgroup: &GoSkipTest_SkipGroup{ + GroupInt32: Int32(75), + GroupString: String("wxyz"), + }, + } + + // Marshal it into same buffer. + o.Marshal(skip) + + pbd := new(GoTestField) + o.Unmarshal(pbd) + + // The __unrecognized field should be a marshaling of GoSkipTest + skipd := new(GoSkipTest) + + o.SetBuf(pbd.XXX_unrecognized) + o.Unmarshal(skipd) + + if *skipd.SkipInt32 != *skip.SkipInt32 { + t.Error("skip int32", skipd.SkipInt32) + } + if *skipd.SkipFixed32 != *skip.SkipFixed32 { + t.Error("skip fixed32", skipd.SkipFixed32) + } + if *skipd.SkipFixed64 != *skip.SkipFixed64 { + t.Error("skip fixed64", skipd.SkipFixed64) + } + if *skipd.SkipString != *skip.SkipString { + t.Error("skip string", *skipd.SkipString) + } + if *skipd.Skipgroup.GroupInt32 != *skip.Skipgroup.GroupInt32 { + t.Error("skip group int32", skipd.Skipgroup.GroupInt32) + } + if *skipd.Skipgroup.GroupString != *skip.Skipgroup.GroupString { + t.Error("skip group string", *skipd.Skipgroup.GroupString) + } +} + +// Check that unrecognized fields of a submessage are preserved. +func TestSubmessageUnrecognizedFields(t *testing.T) { + nm := &NewMessage{ + Nested: &NewMessage_Nested{ + Name: String("Nigel"), + FoodGroup: String("carbs"), + }, + } + b, err := Marshal(nm) + if err != nil { + t.Fatalf("Marshal of NewMessage: %v", err) + } + + // Unmarshal into an OldMessage. + om := new(OldMessage) + if err := Unmarshal(b, om); err != nil { + t.Fatalf("Unmarshal to OldMessage: %v", err) + } + exp := &OldMessage{ + Nested: &OldMessage_Nested{ + Name: String("Nigel"), + // normal protocol buffer users should not do this + XXX_unrecognized: []byte("\x12\x05carbs"), + }, + } + if !Equal(om, exp) { + t.Errorf("om = %v, want %v", om, exp) + } + + // Clone the OldMessage. + om = Clone(om).(*OldMessage) + if !Equal(om, exp) { + t.Errorf("Clone(om) = %v, want %v", om, exp) + } + + // Marshal the OldMessage, then unmarshal it into an empty NewMessage. + if b, err = Marshal(om); err != nil { + t.Fatalf("Marshal of OldMessage: %v", err) + } + t.Logf("Marshal(%v) -> %q", om, b) + nm2 := new(NewMessage) + if err := Unmarshal(b, nm2); err != nil { + t.Fatalf("Unmarshal to NewMessage: %v", err) + } + if !Equal(nm, nm2) { + t.Errorf("NewMessage round-trip: %v => %v", nm, nm2) + } +} + +// Check that an int32 field can be upgraded to an int64 field. +func TestNegativeInt32(t *testing.T) { + om := &OldMessage{ + Num: Int32(-1), + } + b, err := Marshal(om) + if err != nil { + t.Fatalf("Marshal of OldMessage: %v", err) + } + + // Check the size. It should be 11 bytes; + // 1 for the field/wire type, and 10 for the negative number. + if len(b) != 11 { + t.Errorf("%v marshaled as %q, wanted 11 bytes", om, b) + } + + // Unmarshal into a NewMessage. + nm := new(NewMessage) + if err := Unmarshal(b, nm); err != nil { + t.Fatalf("Unmarshal to NewMessage: %v", err) + } + want := &NewMessage{ + Num: Int64(-1), + } + if !Equal(nm, want) { + t.Errorf("nm = %v, want %v", nm, want) + } +} + +// Check that we can grow an array (repeated field) to have many elements. +// This test doesn't depend only on our encoding; for variety, it makes sure +// we create, encode, and decode the correct contents explicitly. It's therefore +// a bit messier. +// This test also uses (and hence tests) the Marshal/Unmarshal functions +// instead of the methods. +func TestBigRepeated(t *testing.T) { + pb := initGoTest(true) + + // Create the arrays + const N = 50 // Internally the library starts much smaller. + pb.Repeatedgroup = make([]*GoTest_RepeatedGroup, N) + pb.F_Sint64Repeated = make([]int64, N) + pb.F_Sint32Repeated = make([]int32, N) + pb.F_BytesRepeated = make([][]byte, N) + pb.F_StringRepeated = make([]string, N) + pb.F_DoubleRepeated = make([]float64, N) + pb.F_FloatRepeated = make([]float32, N) + pb.F_Uint64Repeated = make([]uint64, N) + pb.F_Uint32Repeated = make([]uint32, N) + pb.F_Fixed64Repeated = make([]uint64, N) + pb.F_Fixed32Repeated = make([]uint32, N) + pb.F_Int64Repeated = make([]int64, N) + pb.F_Int32Repeated = make([]int32, N) + pb.F_BoolRepeated = make([]bool, N) + pb.RepeatedField = make([]*GoTestField, N) + + // Fill in the arrays with checkable values. + igtf := initGoTestField() + igtrg := initGoTest_RepeatedGroup() + for i := 0; i < N; i++ { + pb.Repeatedgroup[i] = igtrg + pb.F_Sint64Repeated[i] = int64(i) + pb.F_Sint32Repeated[i] = int32(i) + s := fmt.Sprint(i) + pb.F_BytesRepeated[i] = []byte(s) + pb.F_StringRepeated[i] = s + pb.F_DoubleRepeated[i] = float64(i) + pb.F_FloatRepeated[i] = float32(i) + pb.F_Uint64Repeated[i] = uint64(i) + pb.F_Uint32Repeated[i] = uint32(i) + pb.F_Fixed64Repeated[i] = uint64(i) + pb.F_Fixed32Repeated[i] = uint32(i) + pb.F_Int64Repeated[i] = int64(i) + pb.F_Int32Repeated[i] = int32(i) + pb.F_BoolRepeated[i] = i%2 == 0 + pb.RepeatedField[i] = igtf + } + + // Marshal. + buf, _ := Marshal(pb) + + // Now test Unmarshal by recreating the original buffer. + pbd := new(GoTest) + Unmarshal(buf, pbd) + + // Check the checkable values + for i := uint64(0); i < N; i++ { + if pbd.Repeatedgroup[i] == nil { // TODO: more checking? + t.Error("pbd.Repeatedgroup bad") + } + var x uint64 + x = uint64(pbd.F_Sint64Repeated[i]) + if x != i { + t.Error("pbd.F_Sint64Repeated bad", x, i) + } + x = uint64(pbd.F_Sint32Repeated[i]) + if x != i { + t.Error("pbd.F_Sint32Repeated bad", x, i) + } + s := fmt.Sprint(i) + equalbytes(pbd.F_BytesRepeated[i], []byte(s), t) + if pbd.F_StringRepeated[i] != s { + t.Error("pbd.F_Sint32Repeated bad", pbd.F_StringRepeated[i], i) + } + x = uint64(pbd.F_DoubleRepeated[i]) + if x != i { + t.Error("pbd.F_DoubleRepeated bad", x, i) + } + x = uint64(pbd.F_FloatRepeated[i]) + if x != i { + t.Error("pbd.F_FloatRepeated bad", x, i) + } + x = pbd.F_Uint64Repeated[i] + if x != i { + t.Error("pbd.F_Uint64Repeated bad", x, i) + } + x = uint64(pbd.F_Uint32Repeated[i]) + if x != i { + t.Error("pbd.F_Uint32Repeated bad", x, i) + } + x = pbd.F_Fixed64Repeated[i] + if x != i { + t.Error("pbd.F_Fixed64Repeated bad", x, i) + } + x = uint64(pbd.F_Fixed32Repeated[i]) + if x != i { + t.Error("pbd.F_Fixed32Repeated bad", x, i) + } + x = uint64(pbd.F_Int64Repeated[i]) + if x != i { + t.Error("pbd.F_Int64Repeated bad", x, i) + } + x = uint64(pbd.F_Int32Repeated[i]) + if x != i { + t.Error("pbd.F_Int32Repeated bad", x, i) + } + if pbd.F_BoolRepeated[i] != (i%2 == 0) { + t.Error("pbd.F_BoolRepeated bad", x, i) + } + if pbd.RepeatedField[i] == nil { // TODO: more checking? + t.Error("pbd.RepeatedField bad") + } + } +} + +// Verify we give a useful message when decoding to the wrong structure type. +func TestTypeMismatch(t *testing.T) { + pb1 := initGoTest(true) + + // Marshal + o := old() + o.Marshal(pb1) + + // Now Unmarshal it to the wrong type. + pb2 := initGoTestField() + err := o.Unmarshal(pb2) + if err == nil { + t.Error("expected error, got no error") + } else if !strings.Contains(err.Error(), "bad wiretype") { + t.Error("expected bad wiretype error, got", err) + } +} + +func encodeDecode(t *testing.T, in, out Message, msg string) { + buf, err := Marshal(in) + if err != nil { + t.Fatalf("failed marshaling %v: %v", msg, err) + } + if err := Unmarshal(buf, out); err != nil { + t.Fatalf("failed unmarshaling %v: %v", msg, err) + } +} + +func TestPackedNonPackedDecoderSwitching(t *testing.T) { + np, p := new(NonPackedTest), new(PackedTest) + + // non-packed -> packed + np.A = []int32{0, 1, 1, 2, 3, 5} + encodeDecode(t, np, p, "non-packed -> packed") + if !reflect.DeepEqual(np.A, p.B) { + t.Errorf("failed non-packed -> packed; np.A=%+v, p.B=%+v", np.A, p.B) + } + + // packed -> non-packed + np.Reset() + p.B = []int32{3, 1, 4, 1, 5, 9} + encodeDecode(t, p, np, "packed -> non-packed") + if !reflect.DeepEqual(p.B, np.A) { + t.Errorf("failed packed -> non-packed; p.B=%+v, np.A=%+v", p.B, np.A) + } +} + +func TestProto1RepeatedGroup(t *testing.T) { + pb := &MessageList{ + Message: []*MessageList_Message{ + { + Name: String("blah"), + Count: Int32(7), + }, + // NOTE: pb.Message[1] is a nil + nil, + }, + } + + o := old() + err := o.Marshal(pb) + if err == nil || !strings.Contains(err.Error(), "repeated field Message has nil") { + t.Fatalf("unexpected or no error when marshaling: %v", err) + } +} + +// Test that enums work. Checks for a bug introduced by making enums +// named types instead of int32: newInt32FromUint64 would crash with +// a type mismatch in reflect.PointTo. +func TestEnum(t *testing.T) { + pb := new(GoEnum) + pb.Foo = FOO_FOO1.Enum() + o := old() + if err := o.Marshal(pb); err != nil { + t.Fatal("error encoding enum:", err) + } + pb1 := new(GoEnum) + if err := o.Unmarshal(pb1); err != nil { + t.Fatal("error decoding enum:", err) + } + if *pb1.Foo != FOO_FOO1 { + t.Error("expected 7 but got ", *pb1.Foo) + } +} + +// Enum types have String methods. Check that enum fields can be printed. +// We don't care what the value actually is, just as long as it doesn't crash. +func TestPrintingNilEnumFields(t *testing.T) { + pb := new(GoEnum) + _ = fmt.Sprintf("%+v", pb) +} + +// Verify that absent required fields cause Marshal/Unmarshal to return errors. +func TestRequiredFieldEnforcement(t *testing.T) { + pb := new(GoTestField) + _, err := Marshal(pb) + if err == nil { + t.Error("marshal: expected error, got nil") + } else if strings.Index(err.Error(), "Label") < 0 { + t.Errorf("marshal: bad error type: %v", err) + } + + // A slightly sneaky, yet valid, proto. It encodes the same required field twice, + // so simply counting the required fields is insufficient. + // field 1, encoding 2, value "hi" + buf := []byte("\x0A\x02hi\x0A\x02hi") + err = Unmarshal(buf, pb) + if err == nil { + t.Error("unmarshal: expected error, got nil") + } else if strings.Index(err.Error(), "{Unknown}") < 0 { + t.Errorf("unmarshal: bad error type: %v", err) + } +} + +func TestTypedNilMarshal(t *testing.T) { + // A typed nil should return ErrNil and not crash. + _, err := Marshal((*GoEnum)(nil)) + if err != ErrNil { + t.Errorf("Marshal: got err %v, want ErrNil", err) + } +} + +// A type that implements the Marshaler interface, but is not nillable. +type nonNillableInt uint64 + +func (nni nonNillableInt) Marshal() ([]byte, error) { + return EncodeVarint(uint64(nni)), nil +} + +type NNIMessage struct { + nni nonNillableInt +} + +func (*NNIMessage) Reset() {} +func (*NNIMessage) String() string { return "" } +func (*NNIMessage) ProtoMessage() {} + +// A type that implements the Marshaler interface and is nillable. +type nillableMessage struct { + x uint64 +} + +func (nm *nillableMessage) Marshal() ([]byte, error) { + return EncodeVarint(nm.x), nil +} + +type NMMessage struct { + nm *nillableMessage +} + +func (*NMMessage) Reset() {} +func (*NMMessage) String() string { return "" } +func (*NMMessage) ProtoMessage() {} + +// Verify a type that uses the Marshaler interface, but has a nil pointer. +func TestNilMarshaler(t *testing.T) { + // Try a struct with a Marshaler field that is nil. + // It should be directly marshable. + nmm := new(NMMessage) + if _, err := Marshal(nmm); err != nil { + t.Error("unexpected error marshaling nmm: ", err) + } + + // Try a struct with a Marshaler field that is not nillable. + nnim := new(NNIMessage) + nnim.nni = 7 + var _ Marshaler = nnim.nni // verify it is truly a Marshaler + if _, err := Marshal(nnim); err != nil { + t.Error("unexpected error marshaling nnim: ", err) + } +} + +func TestAllSetDefaults(t *testing.T) { + // Exercise SetDefaults with all scalar field types. + m := &Defaults{ + // NaN != NaN, so override that here. + F_Nan: Float32(1.7), + } + expected := &Defaults{ + F_Bool: Bool(true), + F_Int32: Int32(32), + F_Int64: Int64(64), + F_Fixed32: Uint32(320), + F_Fixed64: Uint64(640), + F_Uint32: Uint32(3200), + F_Uint64: Uint64(6400), + F_Float: Float32(314159), + F_Double: Float64(271828), + F_String: String(`hello, "world!"` + "\n"), + F_Bytes: []byte("Bignose"), + F_Sint32: Int32(-32), + F_Sint64: Int64(-64), + F_Enum: Defaults_GREEN.Enum(), + F_Pinf: Float32(float32(math.Inf(1))), + F_Ninf: Float32(float32(math.Inf(-1))), + F_Nan: Float32(1.7), + StrZero: String(""), + } + SetDefaults(m) + if !Equal(m, expected) { + t.Errorf("SetDefaults failed\n got %v\nwant %v", m, expected) + } +} + +func TestSetDefaultsWithSetField(t *testing.T) { + // Check that a set value is not overridden. + m := &Defaults{ + F_Int32: Int32(12), + } + SetDefaults(m) + if v := m.GetF_Int32(); v != 12 { + t.Errorf("m.FInt32 = %v, want 12", v) + } +} + +func TestSetDefaultsWithSubMessage(t *testing.T) { + m := &OtherMessage{ + Key: Int64(123), + Inner: &InnerMessage{ + Host: String("gopher"), + }, + } + expected := &OtherMessage{ + Key: Int64(123), + Inner: &InnerMessage{ + Host: String("gopher"), + Port: Int32(4000), + }, + } + SetDefaults(m) + if !Equal(m, expected) { + t.Errorf("\n got %v\nwant %v", m, expected) + } +} + +func TestSetDefaultsWithRepeatedSubMessage(t *testing.T) { + m := &MyMessage{ + RepInner: []*InnerMessage{{}}, + } + expected := &MyMessage{ + RepInner: []*InnerMessage{{ + Port: Int32(4000), + }}, + } + SetDefaults(m) + if !Equal(m, expected) { + t.Errorf("\n got %v\nwant %v", m, expected) + } +} + +func TestSetDefaultWithRepeatedNonMessage(t *testing.T) { + m := &MyMessage{ + Pet: []string{"turtle", "wombat"}, + } + expected := Clone(m) + SetDefaults(m) + if !Equal(m, expected) { + t.Errorf("\n got %v\nwant %v", m, expected) + } +} + +func TestMaximumTagNumber(t *testing.T) { + m := &MaxTag{ + LastField: String("natural goat essence"), + } + buf, err := Marshal(m) + if err != nil { + t.Fatalf("proto.Marshal failed: %v", err) + } + m2 := new(MaxTag) + if err := Unmarshal(buf, m2); err != nil { + t.Fatalf("proto.Unmarshal failed: %v", err) + } + if got, want := m2.GetLastField(), *m.LastField; got != want { + t.Errorf("got %q, want %q", got, want) + } +} + +func TestJSON(t *testing.T) { + m := &MyMessage{ + Count: Int32(4), + Pet: []string{"bunny", "kitty"}, + Inner: &InnerMessage{ + Host: String("cauchy"), + }, + Bikeshed: MyMessage_GREEN.Enum(), + } + const expected = `{"count":4,"pet":["bunny","kitty"],"inner":{"host":"cauchy"},"bikeshed":1}` + + b, err := json.Marshal(m) + if err != nil { + t.Fatalf("json.Marshal failed: %v", err) + } + s := string(b) + if s != expected { + t.Errorf("got %s\nwant %s", s, expected) + } + + received := new(MyMessage) + if err := json.Unmarshal(b, received); err != nil { + t.Fatalf("json.Unmarshal failed: %v", err) + } + if !Equal(received, m) { + t.Fatalf("got %s, want %s", received, m) + } + + // Test unmarshalling of JSON with symbolic enum name. + const old = `{"count":4,"pet":["bunny","kitty"],"inner":{"host":"cauchy"},"bikeshed":"GREEN"}` + received.Reset() + if err := json.Unmarshal([]byte(old), received); err != nil { + t.Fatalf("json.Unmarshal failed: %v", err) + } + if !Equal(received, m) { + t.Fatalf("got %s, want %s", received, m) + } +} + +func TestBadWireType(t *testing.T) { + b := []byte{7<<3 | 6} // field 7, wire type 6 + pb := new(OtherMessage) + if err := Unmarshal(b, pb); err == nil { + t.Errorf("Unmarshal did not fail") + } else if !strings.Contains(err.Error(), "unknown wire type") { + t.Errorf("wrong error: %v", err) + } +} + +func TestBytesWithInvalidLength(t *testing.T) { + // If a byte sequence has an invalid (negative) length, Unmarshal should not panic. + b := []byte{2<<3 | WireBytes, 0xff, 0xff, 0xff, 0xff, 0xff, 0} + Unmarshal(b, new(MyMessage)) +} + +func TestLengthOverflow(t *testing.T) { + // Overflowing a length should not panic. + b := []byte{2<<3 | WireBytes, 1, 1, 3<<3 | WireBytes, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x01} + Unmarshal(b, new(MyMessage)) +} + +func TestVarintOverflow(t *testing.T) { + // Overflowing a 64-bit length should not be allowed. + b := []byte{1<<3 | WireVarint, 0x01, 3<<3 | WireBytes, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01} + if err := Unmarshal(b, new(MyMessage)); err == nil { + t.Fatalf("Overflowed uint64 length without error") + } +} + +func TestUnmarshalFuzz(t *testing.T) { + const N = 1000 + seed := time.Now().UnixNano() + t.Logf("RNG seed is %d", seed) + rng := rand.New(rand.NewSource(seed)) + buf := make([]byte, 20) + for i := 0; i < N; i++ { + for j := range buf { + buf[j] = byte(rng.Intn(256)) + } + fuzzUnmarshal(t, buf) + } +} + +func TestMergeMessages(t *testing.T) { + pb := &MessageList{Message: []*MessageList_Message{{Name: String("x"), Count: Int32(1)}}} + data, err := Marshal(pb) + if err != nil { + t.Fatalf("Marshal: %v", err) + } + + pb1 := new(MessageList) + if err := Unmarshal(data, pb1); err != nil { + t.Fatalf("first Unmarshal: %v", err) + } + if err := Unmarshal(data, pb1); err != nil { + t.Fatalf("second Unmarshal: %v", err) + } + if len(pb1.Message) != 1 { + t.Errorf("two Unmarshals produced %d Messages, want 1", len(pb1.Message)) + } + + pb2 := new(MessageList) + if err := UnmarshalMerge(data, pb2); err != nil { + t.Fatalf("first UnmarshalMerge: %v", err) + } + if err := UnmarshalMerge(data, pb2); err != nil { + t.Fatalf("second UnmarshalMerge: %v", err) + } + if len(pb2.Message) != 2 { + t.Errorf("two UnmarshalMerges produced %d Messages, want 2", len(pb2.Message)) + } +} + +func TestExtensionMarshalOrder(t *testing.T) { + m := &MyMessage{Count: Int(123)} + if err := SetExtension(m, E_Ext_More, &Ext{Data: String("alpha")}); err != nil { + t.Fatalf("SetExtension: %v", err) + } + if err := SetExtension(m, E_Ext_Text, String("aleph")); err != nil { + t.Fatalf("SetExtension: %v", err) + } + if err := SetExtension(m, E_Ext_Number, Int32(1)); err != nil { + t.Fatalf("SetExtension: %v", err) + } + + // Serialize m several times, and check we get the same bytes each time. + var orig []byte + for i := 0; i < 100; i++ { + b, err := Marshal(m) + if err != nil { + t.Fatalf("Marshal: %v", err) + } + if i == 0 { + orig = b + continue + } + if !bytes.Equal(b, orig) { + t.Errorf("Bytes differ on attempt #%d", i) + } + } +} + +// Many extensions, because small maps might not iterate differently on each iteration. +var exts = []*ExtensionDesc{ + E_X201, + E_X202, + E_X203, + E_X204, + E_X205, + E_X206, + E_X207, + E_X208, + E_X209, + E_X210, + E_X211, + E_X212, + E_X213, + E_X214, + E_X215, + E_X216, + E_X217, + E_X218, + E_X219, + E_X220, + E_X221, + E_X222, + E_X223, + E_X224, + E_X225, + E_X226, + E_X227, + E_X228, + E_X229, + E_X230, + E_X231, + E_X232, + E_X233, + E_X234, + E_X235, + E_X236, + E_X237, + E_X238, + E_X239, + E_X240, + E_X241, + E_X242, + E_X243, + E_X244, + E_X245, + E_X246, + E_X247, + E_X248, + E_X249, + E_X250, +} + +func TestMessageSetMarshalOrder(t *testing.T) { + m := &MyMessageSet{} + for _, x := range exts { + if err := SetExtension(m, x, &Empty{}); err != nil { + t.Fatalf("SetExtension: %v", err) + } + } + + buf, err := Marshal(m) + if err != nil { + t.Fatalf("Marshal: %v", err) + } + + // Serialize m several times, and check we get the same bytes each time. + for i := 0; i < 10; i++ { + b1, err := Marshal(m) + if err != nil { + t.Fatalf("Marshal: %v", err) + } + if !bytes.Equal(b1, buf) { + t.Errorf("Bytes differ on re-Marshal #%d", i) + } + + m2 := &MyMessageSet{} + if err := Unmarshal(buf, m2); err != nil { + t.Errorf("Unmarshal: %v", err) + } + b2, err := Marshal(m2) + if err != nil { + t.Errorf("re-Marshal: %v", err) + } + if !bytes.Equal(b2, buf) { + t.Errorf("Bytes differ on round-trip #%d", i) + } + } +} + +func TestUnmarshalMergesMessages(t *testing.T) { + // If a nested message occurs twice in the input, + // the fields should be merged when decoding. + a := &OtherMessage{ + Key: Int64(123), + Inner: &InnerMessage{ + Host: String("polhode"), + Port: Int32(1234), + }, + } + aData, err := Marshal(a) + if err != nil { + t.Fatalf("Marshal(a): %v", err) + } + b := &OtherMessage{ + Weight: Float32(1.2), + Inner: &InnerMessage{ + Host: String("herpolhode"), + Connected: Bool(true), + }, + } + bData, err := Marshal(b) + if err != nil { + t.Fatalf("Marshal(b): %v", err) + } + want := &OtherMessage{ + Key: Int64(123), + Weight: Float32(1.2), + Inner: &InnerMessage{ + Host: String("herpolhode"), + Port: Int32(1234), + Connected: Bool(true), + }, + } + got := new(OtherMessage) + if err := Unmarshal(append(aData, bData...), got); err != nil { + t.Fatalf("Unmarshal: %v", err) + } + if !Equal(got, want) { + t.Errorf("\n got %v\nwant %v", got, want) + } +} + +func TestEncodingSizes(t *testing.T) { + tests := []struct { + m Message + n int + }{ + {&Defaults{F_Int32: Int32(math.MaxInt32)}, 6}, + {&Defaults{F_Int32: Int32(math.MinInt32)}, 11}, + {&Defaults{F_Uint32: Uint32(uint32(math.MaxInt32) + 1)}, 6}, + {&Defaults{F_Uint32: Uint32(math.MaxUint32)}, 6}, + } + for _, test := range tests { + b, err := Marshal(test.m) + if err != nil { + t.Errorf("Marshal(%v): %v", test.m, err) + continue + } + if len(b) != test.n { + t.Errorf("Marshal(%v) yielded %d bytes, want %d bytes", test.m, len(b), test.n) + } + } +} + +func TestRequiredNotSetError(t *testing.T) { + pb := initGoTest(false) + pb.RequiredField.Label = nil + pb.F_Int32Required = nil + pb.F_Int64Required = nil + + expected := "0807" + // field 1, encoding 0, value 7 + "2206" + "120474797065" + // field 4, encoding 2 (GoTestField) + "5001" + // field 10, encoding 0, value 1 + "6d20000000" + // field 13, encoding 5, value 0x20 + "714000000000000000" + // field 14, encoding 1, value 0x40 + "78a019" + // field 15, encoding 0, value 0xca0 = 3232 + "8001c032" + // field 16, encoding 0, value 0x1940 = 6464 + "8d0100004a45" + // field 17, encoding 5, value 3232.0 + "9101000000000040b940" + // field 18, encoding 1, value 6464.0 + "9a0106" + "737472696e67" + // field 19, encoding 2, string "string" + "b304" + // field 70, encoding 3, start group + "ba0408" + "7265717569726564" + // field 71, encoding 2, string "required" + "b404" + // field 70, encoding 4, end group + "aa0605" + "6279746573" + // field 101, encoding 2, string "bytes" + "b0063f" + // field 102, encoding 0, 0x3f zigzag32 + "b8067f" // field 103, encoding 0, 0x7f zigzag64 + + o := old() + bytes, err := Marshal(pb) + if _, ok := err.(*RequiredNotSetError); !ok { + fmt.Printf("marshal-1 err = %v, want *RequiredNotSetError", err) + o.DebugPrint("", bytes) + t.Fatalf("expected = %s", expected) + } + if strings.Index(err.Error(), "RequiredField.Label") < 0 { + t.Errorf("marshal-1 wrong err msg: %v", err) + } + if !equal(bytes, expected, t) { + o.DebugPrint("neq 1", bytes) + t.Fatalf("expected = %s", expected) + } + + // Now test Unmarshal by recreating the original buffer. + pbd := new(GoTest) + err = Unmarshal(bytes, pbd) + if _, ok := err.(*RequiredNotSetError); !ok { + t.Fatalf("unmarshal err = %v, want *RequiredNotSetError", err) + o.DebugPrint("", bytes) + t.Fatalf("string = %s", expected) + } + if strings.Index(err.Error(), "RequiredField.{Unknown}") < 0 { + t.Errorf("unmarshal wrong err msg: %v", err) + } + bytes, err = Marshal(pbd) + if _, ok := err.(*RequiredNotSetError); !ok { + t.Errorf("marshal-2 err = %v, want *RequiredNotSetError", err) + o.DebugPrint("", bytes) + t.Fatalf("string = %s", expected) + } + if strings.Index(err.Error(), "RequiredField.Label") < 0 { + t.Errorf("marshal-2 wrong err msg: %v", err) + } + if !equal(bytes, expected, t) { + o.DebugPrint("neq 2", bytes) + t.Fatalf("string = %s", expected) + } +} + +func fuzzUnmarshal(t *testing.T, data []byte) { + defer func() { + if e := recover(); e != nil { + t.Errorf("These bytes caused a panic: %+v", data) + t.Logf("Stack:\n%s", debug.Stack()) + t.FailNow() + } + }() + + pb := new(MyMessage) + Unmarshal(data, pb) +} + +func TestMapFieldMarshal(t *testing.T) { + m := &MessageWithMap{ + NameMapping: map[int32]string{ + 1: "Rob", + 4: "Ian", + 8: "Dave", + }, + } + b, err := Marshal(m) + if err != nil { + t.Fatalf("Marshal: %v", err) + } + + // b should be the concatenation of these three byte sequences in some order. + parts := []string{ + "\n\a\b\x01\x12\x03Rob", + "\n\a\b\x04\x12\x03Ian", + "\n\b\b\x08\x12\x04Dave", + } + ok := false + for i := range parts { + for j := range parts { + if j == i { + continue + } + for k := range parts { + if k == i || k == j { + continue + } + try := parts[i] + parts[j] + parts[k] + if bytes.Equal(b, []byte(try)) { + ok = true + break + } + } + } + } + if !ok { + t.Fatalf("Incorrect Marshal output.\n got %q\nwant %q (or a permutation of that)", b, parts[0]+parts[1]+parts[2]) + } + t.Logf("FYI b: %q", b) + + (new(Buffer)).DebugPrint("Dump of b", b) +} + +func TestMapFieldRoundTrips(t *testing.T) { + m := &MessageWithMap{ + NameMapping: map[int32]string{ + 1: "Rob", + 4: "Ian", + 8: "Dave", + }, + MsgMapping: map[int64]*FloatingPoint{ + 0x7001: {F: Float64(2.0)}, + }, + ByteMapping: map[bool][]byte{ + false: []byte("that's not right!"), + true: []byte("aye, 'tis true!"), + }, + } + b, err := Marshal(m) + if err != nil { + t.Fatalf("Marshal: %v", err) + } + t.Logf("FYI b: %q", b) + m2 := new(MessageWithMap) + if err := Unmarshal(b, m2); err != nil { + t.Fatalf("Unmarshal: %v", err) + } + for _, pair := range [][2]interface{}{ + {m.NameMapping, m2.NameMapping}, + {m.MsgMapping, m2.MsgMapping}, + {m.ByteMapping, m2.ByteMapping}, + } { + if !reflect.DeepEqual(pair[0], pair[1]) { + t.Errorf("Map did not survive a round trip.\ninitial: %v\n final: %v", pair[0], pair[1]) + } + } +} + +func TestMapFieldWithNil(t *testing.T) { + m := &MessageWithMap{ + MsgMapping: map[int64]*FloatingPoint{ + 1: nil, + }, + } + b, err := Marshal(m) + if err == nil { + t.Fatalf("Marshal of bad map should have failed, got these bytes: %v", b) + } +} + +func TestOneof(t *testing.T) { + m := &Communique{} + b, err := Marshal(m) + if err != nil { + t.Fatalf("Marshal of empty message with oneof: %v", err) + } + if len(b) != 0 { + t.Errorf("Marshal of empty message yielded too many bytes: %v", b) + } + + m = &Communique{ + Union: &Communique_Name{"Barry"}, + } + + // Round-trip. + b, err = Marshal(m) + if err != nil { + t.Fatalf("Marshal of message with oneof: %v", err) + } + if len(b) != 7 { // name tag/wire (1) + name len (1) + name (5) + t.Errorf("Incorrect marshal of message with oneof: %v", b) + } + m.Reset() + if err := Unmarshal(b, m); err != nil { + t.Fatalf("Unmarshal of message with oneof: %v", err) + } + if x, ok := m.Union.(*Communique_Name); !ok || x.Name != "Barry" { + t.Errorf("After round trip, Union = %+v", m.Union) + } + if name := m.GetName(); name != "Barry" { + t.Errorf("After round trip, GetName = %q, want %q", name, "Barry") + } + + // Let's try with a message in the oneof. + m.Union = &Communique_Msg{&Strings{StringField: String("deep deep string")}} + b, err = Marshal(m) + if err != nil { + t.Fatalf("Marshal of message with oneof set to message: %v", err) + } + if len(b) != 20 { // msg tag/wire (1) + msg len (1) + msg (1 + 1 + 16) + t.Errorf("Incorrect marshal of message with oneof set to message: %v", b) + } + m.Reset() + if err := Unmarshal(b, m); err != nil { + t.Fatalf("Unmarshal of message with oneof set to message: %v", err) + } + ss, ok := m.Union.(*Communique_Msg) + if !ok || ss.Msg.GetStringField() != "deep deep string" { + t.Errorf("After round trip with oneof set to message, Union = %+v", m.Union) + } +} + +func TestInefficientPackedBool(t *testing.T) { + // https://github.com/golang/protobuf/issues/76 + inp := []byte{ + 0x12, 0x02, // 0x12 = 2<<3|2; 2 bytes + // Usually a bool should take a single byte, + // but it is permitted to be any varint. + 0xb9, 0x30, + } + if err := Unmarshal(inp, new(MoreRepeated)); err != nil { + t.Error(err) + } +} + +// Benchmarks + +func testMsg() *GoTest { + pb := initGoTest(true) + const N = 1000 // Internally the library starts much smaller. + pb.F_Int32Repeated = make([]int32, N) + pb.F_DoubleRepeated = make([]float64, N) + for i := 0; i < N; i++ { + pb.F_Int32Repeated[i] = int32(i) + pb.F_DoubleRepeated[i] = float64(i) + } + return pb +} + +func bytesMsg() *GoTest { + pb := initGoTest(true) + buf := make([]byte, 4000) + for i := range buf { + buf[i] = byte(i) + } + pb.F_BytesDefaulted = buf + return pb +} + +func benchmarkMarshal(b *testing.B, pb Message, marshal func(Message) ([]byte, error)) { + d, _ := marshal(pb) + b.SetBytes(int64(len(d))) + b.ResetTimer() + for i := 0; i < b.N; i++ { + marshal(pb) + } +} + +func benchmarkBufferMarshal(b *testing.B, pb Message) { + p := NewBuffer(nil) + benchmarkMarshal(b, pb, func(pb0 Message) ([]byte, error) { + p.Reset() + err := p.Marshal(pb0) + return p.Bytes(), err + }) +} + +func benchmarkSize(b *testing.B, pb Message) { + benchmarkMarshal(b, pb, func(pb0 Message) ([]byte, error) { + Size(pb) + return nil, nil + }) +} + +func newOf(pb Message) Message { + in := reflect.ValueOf(pb) + if in.IsNil() { + return pb + } + return reflect.New(in.Type().Elem()).Interface().(Message) +} + +func benchmarkUnmarshal(b *testing.B, pb Message, unmarshal func([]byte, Message) error) { + d, _ := Marshal(pb) + b.SetBytes(int64(len(d))) + pbd := newOf(pb) + + b.ResetTimer() + for i := 0; i < b.N; i++ { + unmarshal(d, pbd) + } +} + +func benchmarkBufferUnmarshal(b *testing.B, pb Message) { + p := NewBuffer(nil) + benchmarkUnmarshal(b, pb, func(d []byte, pb0 Message) error { + p.SetBuf(d) + return p.Unmarshal(pb0) + }) +} + +// Benchmark{Marshal,BufferMarshal,Size,Unmarshal,BufferUnmarshal}{,Bytes} + +func BenchmarkMarshal(b *testing.B) { + benchmarkMarshal(b, testMsg(), Marshal) +} + +func BenchmarkBufferMarshal(b *testing.B) { + benchmarkBufferMarshal(b, testMsg()) +} + +func BenchmarkSize(b *testing.B) { + benchmarkSize(b, testMsg()) +} + +func BenchmarkUnmarshal(b *testing.B) { + benchmarkUnmarshal(b, testMsg(), Unmarshal) +} + +func BenchmarkBufferUnmarshal(b *testing.B) { + benchmarkBufferUnmarshal(b, testMsg()) +} + +func BenchmarkMarshalBytes(b *testing.B) { + benchmarkMarshal(b, bytesMsg(), Marshal) +} + +func BenchmarkBufferMarshalBytes(b *testing.B) { + benchmarkBufferMarshal(b, bytesMsg()) +} + +func BenchmarkSizeBytes(b *testing.B) { + benchmarkSize(b, bytesMsg()) +} + +func BenchmarkUnmarshalBytes(b *testing.B) { + benchmarkUnmarshal(b, bytesMsg(), Unmarshal) +} + +func BenchmarkBufferUnmarshalBytes(b *testing.B) { + benchmarkBufferUnmarshal(b, bytesMsg()) +} + +func BenchmarkUnmarshalUnrecognizedFields(b *testing.B) { + b.StopTimer() + pb := initGoTestField() + skip := &GoSkipTest{ + SkipInt32: Int32(32), + SkipFixed32: Uint32(3232), + SkipFixed64: Uint64(6464), + SkipString: String("skipper"), + Skipgroup: &GoSkipTest_SkipGroup{ + GroupInt32: Int32(75), + GroupString: String("wxyz"), + }, + } + + pbd := new(GoTestField) + p := NewBuffer(nil) + p.Marshal(pb) + p.Marshal(skip) + p2 := NewBuffer(nil) + + b.StartTimer() + for i := 0; i < b.N; i++ { + p2.SetBuf(p.Bytes()) + p2.Unmarshal(pbd) + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/clone.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/clone.go new file mode 100644 index 0000000000000000000000000000000000000000..4ff1ff59e7148e854519cedd591595c23f032add --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/clone.go @@ -0,0 +1,228 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2011 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. + +// Protocol buffer deep copy and merge. +// TODO: MessageSet and RawMessage. + +package proto + +import ( + "log" + "reflect" + "strings" +) + +// Clone returns a deep copy of a protocol buffer. +func Clone(pb Message) Message { + in := reflect.ValueOf(pb) + if in.IsNil() { + return pb + } + + out := reflect.New(in.Type().Elem()) + // out is empty so a merge is a deep copy. + mergeStruct(out.Elem(), in.Elem()) + return out.Interface().(Message) +} + +// Merge merges src into dst. +// Required and optional fields that are set in src will be set to that value in dst. +// Elements of repeated fields will be appended. +// Merge panics if src and dst are not the same type, or if dst is nil. +func Merge(dst, src Message) { + in := reflect.ValueOf(src) + out := reflect.ValueOf(dst) + if out.IsNil() { + panic("proto: nil destination") + } + if in.Type() != out.Type() { + // Explicit test prior to mergeStruct so that mistyped nils will fail + panic("proto: type mismatch") + } + if in.IsNil() { + // Merging nil into non-nil is a quiet no-op + return + } + mergeStruct(out.Elem(), in.Elem()) +} + +func mergeStruct(out, in reflect.Value) { + sprop := GetProperties(in.Type()) + for i := 0; i < in.NumField(); i++ { + f := in.Type().Field(i) + if strings.HasPrefix(f.Name, "XXX_") { + continue + } + mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i]) + } + + if emIn, ok := in.Addr().Interface().(extensionsMap); ok { + emOut := out.Addr().Interface().(extensionsMap) + mergeExtension(emOut.ExtensionMap(), emIn.ExtensionMap()) + } else if emIn, ok := in.Addr().Interface().(extensionsBytes); ok { + emOut := out.Addr().Interface().(extensionsBytes) + bIn := emIn.GetExtensions() + bOut := emOut.GetExtensions() + *bOut = append(*bOut, *bIn...) + } + + uf := in.FieldByName("XXX_unrecognized") + if !uf.IsValid() { + return + } + uin := uf.Bytes() + if len(uin) > 0 { + out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...)) + } +} + +// mergeAny performs a merge between two values of the same type. +// viaPtr indicates whether the values were indirected through a pointer (implying proto2). +// prop is set if this is a struct field (it may be nil). +func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) { + if in.Type() == protoMessageType { + if !in.IsNil() { + if out.IsNil() { + out.Set(reflect.ValueOf(Clone(in.Interface().(Message)))) + } else { + Merge(out.Interface().(Message), in.Interface().(Message)) + } + } + return + } + switch in.Kind() { + case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64, + reflect.String, reflect.Uint32, reflect.Uint64: + if !viaPtr && isProto3Zero(in) { + return + } + out.Set(in) + case reflect.Interface: + // Probably a oneof field; copy non-nil values. + if in.IsNil() { + return + } + // Allocate destination if it is not set, or set to a different type. + // Otherwise we will merge as normal. + if out.IsNil() || out.Elem().Type() != in.Elem().Type() { + out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T) + } + mergeAny(out.Elem(), in.Elem(), false, nil) + case reflect.Map: + if in.Len() == 0 { + return + } + if out.IsNil() { + out.Set(reflect.MakeMap(in.Type())) + } + // For maps with value types of *T or []byte we need to deep copy each value. + elemKind := in.Type().Elem().Kind() + for _, key := range in.MapKeys() { + var val reflect.Value + switch elemKind { + case reflect.Ptr: + val = reflect.New(in.Type().Elem().Elem()) + mergeAny(val, in.MapIndex(key), false, nil) + case reflect.Slice: + val = in.MapIndex(key) + val = reflect.ValueOf(append([]byte{}, val.Bytes()...)) + default: + val = in.MapIndex(key) + } + out.SetMapIndex(key, val) + } + case reflect.Ptr: + if in.IsNil() { + return + } + if out.IsNil() { + out.Set(reflect.New(in.Elem().Type())) + } + mergeAny(out.Elem(), in.Elem(), true, nil) + case reflect.Slice: + if in.IsNil() { + return + } + if in.Type().Elem().Kind() == reflect.Uint8 { + // []byte is a scalar bytes field, not a repeated field. + + // Edge case: if this is in a proto3 message, a zero length + // bytes field is considered the zero value, and should not + // be merged. + if prop != nil && prop.proto3 && in.Len() == 0 { + return + } + + // Make a deep copy. + // Append to []byte{} instead of []byte(nil) so that we never end up + // with a nil result. + out.SetBytes(append([]byte{}, in.Bytes()...)) + return + } + n := in.Len() + if out.IsNil() { + out.Set(reflect.MakeSlice(in.Type(), 0, n)) + } + switch in.Type().Elem().Kind() { + case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64, + reflect.String, reflect.Uint32, reflect.Uint64: + out.Set(reflect.AppendSlice(out, in)) + default: + for i := 0; i < n; i++ { + x := reflect.Indirect(reflect.New(in.Type().Elem())) + mergeAny(x, in.Index(i), false, nil) + out.Set(reflect.Append(out, x)) + } + } + case reflect.Struct: + mergeStruct(out, in) + default: + // unknown type, so not a protocol buffer + log.Printf("proto: don't know how to copy %v", in) + } +} + +func mergeExtension(out, in map[int32]Extension) { + for extNum, eIn := range in { + eOut := Extension{desc: eIn.desc} + if eIn.value != nil { + v := reflect.New(reflect.TypeOf(eIn.value)).Elem() + mergeAny(v, reflect.ValueOf(eIn.value), false, nil) + eOut.value = v.Interface() + } + if eIn.enc != nil { + eOut.enc = make([]byte, len(eIn.enc)) + copy(eOut.enc, eIn.enc) + } + + out[extNum] = eOut + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/clone_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/clone_test.go new file mode 100644 index 0000000000000000000000000000000000000000..3bc008e6fc5d07ec7749f320b16c3097ae3b6478 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/clone_test.go @@ -0,0 +1,267 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2011 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 proto_test + +import ( + "testing" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + + proto3pb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/proto3_proto" + pb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata" +) + +var cloneTestMessage = &pb.MyMessage{ + Count: proto.Int32(42), + Name: proto.String("Dave"), + Pet: []string{"bunny", "kitty", "horsey"}, + Inner: &pb.InnerMessage{ + Host: proto.String("niles"), + Port: proto.Int32(9099), + Connected: proto.Bool(true), + }, + Others: []*pb.OtherMessage{ + { + Value: []byte("some bytes"), + }, + }, + Somegroup: &pb.MyMessage_SomeGroup{ + GroupField: proto.Int32(6), + }, + RepBytes: [][]byte{[]byte("sham"), []byte("wow")}, +} + +func init() { + ext := &pb.Ext{ + Data: proto.String("extension"), + } + if err := proto.SetExtension(cloneTestMessage, pb.E_Ext_More, ext); err != nil { + panic("SetExtension: " + err.Error()) + } +} + +func TestClone(t *testing.T) { + m := proto.Clone(cloneTestMessage).(*pb.MyMessage) + if !proto.Equal(m, cloneTestMessage) { + t.Errorf("Clone(%v) = %v", cloneTestMessage, m) + } + + // Verify it was a deep copy. + *m.Inner.Port++ + if proto.Equal(m, cloneTestMessage) { + t.Error("Mutating clone changed the original") + } + // Byte fields and repeated fields should be copied. + if &m.Pet[0] == &cloneTestMessage.Pet[0] { + t.Error("Pet: repeated field not copied") + } + if &m.Others[0] == &cloneTestMessage.Others[0] { + t.Error("Others: repeated field not copied") + } + if &m.Others[0].Value[0] == &cloneTestMessage.Others[0].Value[0] { + t.Error("Others[0].Value: bytes field not copied") + } + if &m.RepBytes[0] == &cloneTestMessage.RepBytes[0] { + t.Error("RepBytes: repeated field not copied") + } + if &m.RepBytes[0][0] == &cloneTestMessage.RepBytes[0][0] { + t.Error("RepBytes[0]: bytes field not copied") + } +} + +func TestCloneNil(t *testing.T) { + var m *pb.MyMessage + if c := proto.Clone(m); !proto.Equal(m, c) { + t.Errorf("Clone(%v) = %v", m, c) + } +} + +var mergeTests = []struct { + src, dst, want proto.Message +}{ + { + src: &pb.MyMessage{ + Count: proto.Int32(42), + }, + dst: &pb.MyMessage{ + Name: proto.String("Dave"), + }, + want: &pb.MyMessage{ + Count: proto.Int32(42), + Name: proto.String("Dave"), + }, + }, + { + src: &pb.MyMessage{ + Inner: &pb.InnerMessage{ + Host: proto.String("hey"), + Connected: proto.Bool(true), + }, + Pet: []string{"horsey"}, + Others: []*pb.OtherMessage{ + { + Value: []byte("some bytes"), + }, + }, + }, + dst: &pb.MyMessage{ + Inner: &pb.InnerMessage{ + Host: proto.String("niles"), + Port: proto.Int32(9099), + }, + Pet: []string{"bunny", "kitty"}, + Others: []*pb.OtherMessage{ + { + Key: proto.Int64(31415926535), + }, + { + // Explicitly test a src=nil field + Inner: nil, + }, + }, + }, + want: &pb.MyMessage{ + Inner: &pb.InnerMessage{ + Host: proto.String("hey"), + Connected: proto.Bool(true), + Port: proto.Int32(9099), + }, + Pet: []string{"bunny", "kitty", "horsey"}, + Others: []*pb.OtherMessage{ + { + Key: proto.Int64(31415926535), + }, + {}, + { + Value: []byte("some bytes"), + }, + }, + }, + }, + { + src: &pb.MyMessage{ + RepBytes: [][]byte{[]byte("wow")}, + }, + dst: &pb.MyMessage{ + Somegroup: &pb.MyMessage_SomeGroup{ + GroupField: proto.Int32(6), + }, + RepBytes: [][]byte{[]byte("sham")}, + }, + want: &pb.MyMessage{ + Somegroup: &pb.MyMessage_SomeGroup{ + GroupField: proto.Int32(6), + }, + RepBytes: [][]byte{[]byte("sham"), []byte("wow")}, + }, + }, + // Check that a scalar bytes field replaces rather than appends. + { + src: &pb.OtherMessage{Value: []byte("foo")}, + dst: &pb.OtherMessage{Value: []byte("bar")}, + want: &pb.OtherMessage{Value: []byte("foo")}, + }, + { + src: &pb.MessageWithMap{ + NameMapping: map[int32]string{6: "Nigel"}, + MsgMapping: map[int64]*pb.FloatingPoint{ + 0x4001: {F: proto.Float64(2.0)}, + }, + ByteMapping: map[bool][]byte{true: []byte("wowsa")}, + }, + dst: &pb.MessageWithMap{ + NameMapping: map[int32]string{ + 6: "Bruce", // should be overwritten + 7: "Andrew", + }, + }, + want: &pb.MessageWithMap{ + NameMapping: map[int32]string{ + 6: "Nigel", + 7: "Andrew", + }, + MsgMapping: map[int64]*pb.FloatingPoint{ + 0x4001: {F: proto.Float64(2.0)}, + }, + ByteMapping: map[bool][]byte{true: []byte("wowsa")}, + }, + }, + // proto3 shouldn't merge zero values, + // in the same way that proto2 shouldn't merge nils. + { + src: &proto3pb.Message{ + Name: "Aaron", + Data: []byte(""), // zero value, but not nil + }, + dst: &proto3pb.Message{ + HeightInCm: 176, + Data: []byte("texas!"), + }, + want: &proto3pb.Message{ + Name: "Aaron", + HeightInCm: 176, + Data: []byte("texas!"), + }, + }, + // Oneof fields should merge by assignment. + { + src: &pb.Communique{ + Union: &pb.Communique_Number{Number: 41}, + }, + dst: &pb.Communique{ + Union: &pb.Communique_Name{Name: "Bobby Tables"}, + }, + want: &pb.Communique{ + Union: &pb.Communique_Number{Number: 41}, + }, + }, + // Oneof nil is the same as not set. + { + src: &pb.Communique{}, + dst: &pb.Communique{ + Union: &pb.Communique_Name{Name: "Bobby Tables"}, + }, + want: &pb.Communique{ + Union: &pb.Communique_Name{Name: "Bobby Tables"}, + }, + }, +} + +func TestMerge(t *testing.T) { + for _, m := range mergeTests { + got := proto.Clone(m.dst) + proto.Merge(got, m.src) + if !proto.Equal(got, m.want) { + t.Errorf("Merge(%v, %v)\n got %v\nwant %v\n", m.dst, m.src, got, m.want) + } + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/decode.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/decode.go new file mode 100644 index 0000000000000000000000000000000000000000..cb5b213f9b9e9cdd00a31cd677cd0e3bca1e7648 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/decode.go @@ -0,0 +1,872 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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 proto + +/* + * Routines for decoding protocol buffer data to construct in-memory representations. + */ + +import ( + "errors" + "fmt" + "io" + "os" + "reflect" +) + +// errOverflow is returned when an integer is too large to be represented. +var errOverflow = errors.New("proto: integer overflow") + +// ErrInternalBadWireType is returned by generated code when an incorrect +// wire type is encountered. It does not get returned to user code. +var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof") + +// The fundamental decoders that interpret bytes on the wire. +// Those that take integer types all return uint64 and are +// therefore of type valueDecoder. + +// DecodeVarint reads a varint-encoded integer from the slice. +// It returns the integer and the number of bytes consumed, or +// zero if there is not enough. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +func DecodeVarint(buf []byte) (x uint64, n int) { + // x, n already 0 + for shift := uint(0); shift < 64; shift += 7 { + if n >= len(buf) { + return 0, 0 + } + b := uint64(buf[n]) + n++ + x |= (b & 0x7F) << shift + if (b & 0x80) == 0 { + return x, n + } + } + + // The number is too large to represent in a 64-bit value. + return 0, 0 +} + +// DecodeVarint reads a varint-encoded integer from the Buffer. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +func (p *Buffer) DecodeVarint() (x uint64, err error) { + // x, err already 0 + + i := p.index + l := len(p.buf) + + for shift := uint(0); shift < 64; shift += 7 { + if i >= l { + err = io.ErrUnexpectedEOF + return + } + b := p.buf[i] + i++ + x |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + p.index = i + return + } + } + + // The number is too large to represent in a 64-bit value. + err = errOverflow + return +} + +// DecodeFixed64 reads a 64-bit integer from the Buffer. +// This is the format for the +// fixed64, sfixed64, and double protocol buffer types. +func (p *Buffer) DecodeFixed64() (x uint64, err error) { + // x, err already 0 + i := p.index + 8 + if i < 0 || i > len(p.buf) { + err = io.ErrUnexpectedEOF + return + } + p.index = i + + x = uint64(p.buf[i-8]) + x |= uint64(p.buf[i-7]) << 8 + x |= uint64(p.buf[i-6]) << 16 + x |= uint64(p.buf[i-5]) << 24 + x |= uint64(p.buf[i-4]) << 32 + x |= uint64(p.buf[i-3]) << 40 + x |= uint64(p.buf[i-2]) << 48 + x |= uint64(p.buf[i-1]) << 56 + return +} + +// DecodeFixed32 reads a 32-bit integer from the Buffer. +// This is the format for the +// fixed32, sfixed32, and float protocol buffer types. +func (p *Buffer) DecodeFixed32() (x uint64, err error) { + // x, err already 0 + i := p.index + 4 + if i < 0 || i > len(p.buf) { + err = io.ErrUnexpectedEOF + return + } + p.index = i + + x = uint64(p.buf[i-4]) + x |= uint64(p.buf[i-3]) << 8 + x |= uint64(p.buf[i-2]) << 16 + x |= uint64(p.buf[i-1]) << 24 + return +} + +// DecodeZigzag64 reads a zigzag-encoded 64-bit integer +// from the Buffer. +// This is the format used for the sint64 protocol buffer type. +func (p *Buffer) DecodeZigzag64() (x uint64, err error) { + x, err = p.DecodeVarint() + if err != nil { + return + } + x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63) + return +} + +// DecodeZigzag32 reads a zigzag-encoded 32-bit integer +// from the Buffer. +// This is the format used for the sint32 protocol buffer type. +func (p *Buffer) DecodeZigzag32() (x uint64, err error) { + x, err = p.DecodeVarint() + if err != nil { + return + } + x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31)) + return +} + +// These are not ValueDecoders: they produce an array of bytes or a string. +// bytes, embedded messages + +// DecodeRawBytes reads a count-delimited byte buffer from the Buffer. +// This is the format used for the bytes protocol buffer +// type and for embedded messages. +func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) { + n, err := p.DecodeVarint() + if err != nil { + return nil, err + } + + nb := int(n) + if nb < 0 { + return nil, fmt.Errorf("proto: bad byte length %d", nb) + } + end := p.index + nb + if end < p.index || end > len(p.buf) { + return nil, io.ErrUnexpectedEOF + } + + if !alloc { + // todo: check if can get more uses of alloc=false + buf = p.buf[p.index:end] + p.index += nb + return + } + + buf = make([]byte, nb) + copy(buf, p.buf[p.index:]) + p.index += nb + return +} + +// DecodeStringBytes reads an encoded string from the Buffer. +// This is the format used for the proto2 string type. +func (p *Buffer) DecodeStringBytes() (s string, err error) { + buf, err := p.DecodeRawBytes(false) + if err != nil { + return + } + return string(buf), nil +} + +// Skip the next item in the buffer. Its wire type is decoded and presented as an argument. +// If the protocol buffer has extensions, and the field matches, add it as an extension. +// Otherwise, if the XXX_unrecognized field exists, append the skipped data there. +func (o *Buffer) skipAndSave(t reflect.Type, tag, wire int, base structPointer, unrecField field) error { + oi := o.index + + err := o.skip(t, tag, wire) + if err != nil { + return err + } + + if !unrecField.IsValid() { + return nil + } + + ptr := structPointer_Bytes(base, unrecField) + + // Add the skipped field to struct field + obuf := o.buf + + o.buf = *ptr + o.EncodeVarint(uint64(tag<<3 | wire)) + *ptr = append(o.buf, obuf[oi:o.index]...) + + o.buf = obuf + + return nil +} + +// Skip the next item in the buffer. Its wire type is decoded and presented as an argument. +func (o *Buffer) skip(t reflect.Type, tag, wire int) error { + + var u uint64 + var err error + + switch wire { + case WireVarint: + _, err = o.DecodeVarint() + case WireFixed64: + _, err = o.DecodeFixed64() + case WireBytes: + _, err = o.DecodeRawBytes(false) + case WireFixed32: + _, err = o.DecodeFixed32() + case WireStartGroup: + for { + u, err = o.DecodeVarint() + if err != nil { + break + } + fwire := int(u & 0x7) + if fwire == WireEndGroup { + break + } + ftag := int(u >> 3) + err = o.skip(t, ftag, fwire) + if err != nil { + break + } + } + default: + err = fmt.Errorf("proto: can't skip unknown wire type %d for %s", wire, t) + } + return err +} + +// Unmarshaler is the interface representing objects that can +// unmarshal themselves. The method should reset the receiver before +// decoding starts. The argument points to data that may be +// overwritten, so implementations should not keep references to the +// buffer. +type Unmarshaler interface { + Unmarshal([]byte) error +} + +// Unmarshal parses the protocol buffer representation in buf and places the +// decoded result in pb. If the struct underlying pb does not match +// the data in buf, the results can be unpredictable. +// +// Unmarshal resets pb before starting to unmarshal, so any +// existing data in pb is always removed. Use UnmarshalMerge +// to preserve and append to existing data. +func Unmarshal(buf []byte, pb Message) error { + pb.Reset() + return UnmarshalMerge(buf, pb) +} + +// UnmarshalMerge parses the protocol buffer representation in buf and +// writes the decoded result to pb. If the struct underlying pb does not match +// the data in buf, the results can be unpredictable. +// +// UnmarshalMerge merges into existing data in pb. +// Most code should use Unmarshal instead. +func UnmarshalMerge(buf []byte, pb Message) error { + // If the object can unmarshal itself, let it. + if u, ok := pb.(Unmarshaler); ok { + return u.Unmarshal(buf) + } + return NewBuffer(buf).Unmarshal(pb) +} + +// DecodeMessage reads a count-delimited message from the Buffer. +func (p *Buffer) DecodeMessage(pb Message) error { + enc, err := p.DecodeRawBytes(false) + if err != nil { + return err + } + return NewBuffer(enc).Unmarshal(pb) +} + +// DecodeGroup reads a tag-delimited group from the Buffer. +func (p *Buffer) DecodeGroup(pb Message) error { + typ, base, err := getbase(pb) + if err != nil { + return err + } + return p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), true, base) +} + +// Unmarshal parses the protocol buffer representation in the +// Buffer and places the decoded result in pb. If the struct +// underlying pb does not match the data in the buffer, the results can be +// unpredictable. +func (p *Buffer) Unmarshal(pb Message) error { + // If the object can unmarshal itself, let it. + if u, ok := pb.(Unmarshaler); ok { + err := u.Unmarshal(p.buf[p.index:]) + p.index = len(p.buf) + return err + } + + typ, base, err := getbase(pb) + if err != nil { + return err + } + + err = p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), false, base) + + if collectStats { + stats.Decode++ + } + + return err +} + +// unmarshalType does the work of unmarshaling a structure. +func (o *Buffer) unmarshalType(st reflect.Type, prop *StructProperties, is_group bool, base structPointer) error { + var state errorState + required, reqFields := prop.reqCount, uint64(0) + + var err error + for err == nil && o.index < len(o.buf) { + oi := o.index + var u uint64 + u, err = o.DecodeVarint() + if err != nil { + break + } + wire := int(u & 0x7) + if wire == WireEndGroup { + if is_group { + return nil // input is satisfied + } + return fmt.Errorf("proto: %s: wiretype end group for non-group", st) + } + tag := int(u >> 3) + if tag <= 0 { + return fmt.Errorf("proto: %s: illegal tag %d (wire type %d)", st, tag, wire) + } + fieldnum, ok := prop.decoderTags.get(tag) + if !ok { + // Maybe it's an extension? + if prop.extendable { + if e := structPointer_Interface(base, st).(extendableProto); isExtensionField(e, int32(tag)) { + if err = o.skip(st, tag, wire); err == nil { + if ee, eok := e.(extensionsMap); eok { + ext := ee.ExtensionMap()[int32(tag)] // may be missing + ext.enc = append(ext.enc, o.buf[oi:o.index]...) + ee.ExtensionMap()[int32(tag)] = ext + } else if ee, eok := e.(extensionsBytes); eok { + ext := ee.GetExtensions() + *ext = append(*ext, o.buf[oi:o.index]...) + } + } + continue + } + } + // Maybe it's a oneof? + if prop.oneofUnmarshaler != nil { + m := structPointer_Interface(base, st).(Message) + // First return value indicates whether tag is a oneof field. + ok, err = prop.oneofUnmarshaler(m, tag, wire, o) + if err == ErrInternalBadWireType { + // Map the error to something more descriptive. + // Do the formatting here to save generated code space. + err = fmt.Errorf("bad wiretype for oneof field in %T", m) + } + if ok { + continue + } + } + err = o.skipAndSave(st, tag, wire, base, prop.unrecField) + continue + } + p := prop.Prop[fieldnum] + + if p.dec == nil { + fmt.Fprintf(os.Stderr, "proto: no protobuf decoder for %s.%s\n", st, st.Field(fieldnum).Name) + continue + } + dec := p.dec + if wire != WireStartGroup && wire != p.WireType { + if wire == WireBytes && p.packedDec != nil { + // a packable field + dec = p.packedDec + } else { + err = fmt.Errorf("proto: bad wiretype for field %s.%s: got wiretype %d, want %d", st, st.Field(fieldnum).Name, wire, p.WireType) + continue + } + } + decErr := dec(o, p, base) + if decErr != nil && !state.shouldContinue(decErr, p) { + err = decErr + } + if err == nil && p.Required { + // Successfully decoded a required field. + if tag <= 64 { + // use bitmap for fields 1-64 to catch field reuse. + var mask uint64 = 1 << uint64(tag-1) + if reqFields&mask == 0 { + // new required field + reqFields |= mask + required-- + } + } else { + // This is imprecise. It can be fooled by a required field + // with a tag > 64 that is encoded twice; that's very rare. + // A fully correct implementation would require allocating + // a data structure, which we would like to avoid. + required-- + } + } + } + if err == nil { + if is_group { + return io.ErrUnexpectedEOF + } + if state.err != nil { + return state.err + } + if required > 0 { + // Not enough information to determine the exact field. If we use extra + // CPU, we could determine the field only if the missing required field + // has a tag <= 64 and we check reqFields. + return &RequiredNotSetError{"{Unknown}"} + } + } + return err +} + +// Individual type decoders +// For each, +// u is the decoded value, +// v is a pointer to the field (pointer) in the struct + +// Sizes of the pools to allocate inside the Buffer. +// The goal is modest amortization and allocation +// on at least 16-byte boundaries. +const ( + boolPoolSize = 16 + uint32PoolSize = 8 + uint64PoolSize = 4 +) + +// Decode a bool. +func (o *Buffer) dec_bool(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + if len(o.bools) == 0 { + o.bools = make([]bool, boolPoolSize) + } + o.bools[0] = u != 0 + *structPointer_Bool(base, p.field) = &o.bools[0] + o.bools = o.bools[1:] + return nil +} + +func (o *Buffer) dec_proto3_bool(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + *structPointer_BoolVal(base, p.field) = u != 0 + return nil +} + +// Decode an int32. +func (o *Buffer) dec_int32(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + word32_Set(structPointer_Word32(base, p.field), o, uint32(u)) + return nil +} + +func (o *Buffer) dec_proto3_int32(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + word32Val_Set(structPointer_Word32Val(base, p.field), uint32(u)) + return nil +} + +// Decode an int64. +func (o *Buffer) dec_int64(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + word64_Set(structPointer_Word64(base, p.field), o, u) + return nil +} + +func (o *Buffer) dec_proto3_int64(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + word64Val_Set(structPointer_Word64Val(base, p.field), o, u) + return nil +} + +// Decode a string. +func (o *Buffer) dec_string(p *Properties, base structPointer) error { + s, err := o.DecodeStringBytes() + if err != nil { + return err + } + *structPointer_String(base, p.field) = &s + return nil +} + +func (o *Buffer) dec_proto3_string(p *Properties, base structPointer) error { + s, err := o.DecodeStringBytes() + if err != nil { + return err + } + *structPointer_StringVal(base, p.field) = s + return nil +} + +// Decode a slice of bytes ([]byte). +func (o *Buffer) dec_slice_byte(p *Properties, base structPointer) error { + b, err := o.DecodeRawBytes(true) + if err != nil { + return err + } + *structPointer_Bytes(base, p.field) = b + return nil +} + +// Decode a slice of bools ([]bool). +func (o *Buffer) dec_slice_bool(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + v := structPointer_BoolSlice(base, p.field) + *v = append(*v, u != 0) + return nil +} + +// Decode a slice of bools ([]bool) in packed format. +func (o *Buffer) dec_slice_packed_bool(p *Properties, base structPointer) error { + v := structPointer_BoolSlice(base, p.field) + + nn, err := o.DecodeVarint() + if err != nil { + return err + } + nb := int(nn) // number of bytes of encoded bools + fin := o.index + nb + if fin < o.index { + return errOverflow + } + + y := *v + for o.index < fin { + u, err := p.valDec(o) + if err != nil { + return err + } + y = append(y, u != 0) + } + + *v = y + return nil +} + +// Decode a slice of int32s ([]int32). +func (o *Buffer) dec_slice_int32(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + structPointer_Word32Slice(base, p.field).Append(uint32(u)) + return nil +} + +// Decode a slice of int32s ([]int32) in packed format. +func (o *Buffer) dec_slice_packed_int32(p *Properties, base structPointer) error { + v := structPointer_Word32Slice(base, p.field) + + nn, err := o.DecodeVarint() + if err != nil { + return err + } + nb := int(nn) // number of bytes of encoded int32s + + fin := o.index + nb + if fin < o.index { + return errOverflow + } + for o.index < fin { + u, err := p.valDec(o) + if err != nil { + return err + } + v.Append(uint32(u)) + } + return nil +} + +// Decode a slice of int64s ([]int64). +func (o *Buffer) dec_slice_int64(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + + structPointer_Word64Slice(base, p.field).Append(u) + return nil +} + +// Decode a slice of int64s ([]int64) in packed format. +func (o *Buffer) dec_slice_packed_int64(p *Properties, base structPointer) error { + v := structPointer_Word64Slice(base, p.field) + + nn, err := o.DecodeVarint() + if err != nil { + return err + } + nb := int(nn) // number of bytes of encoded int64s + + fin := o.index + nb + if fin < o.index { + return errOverflow + } + for o.index < fin { + u, err := p.valDec(o) + if err != nil { + return err + } + v.Append(u) + } + return nil +} + +// Decode a slice of strings ([]string). +func (o *Buffer) dec_slice_string(p *Properties, base structPointer) error { + s, err := o.DecodeStringBytes() + if err != nil { + return err + } + v := structPointer_StringSlice(base, p.field) + *v = append(*v, s) + return nil +} + +// Decode a slice of slice of bytes ([][]byte). +func (o *Buffer) dec_slice_slice_byte(p *Properties, base structPointer) error { + b, err := o.DecodeRawBytes(true) + if err != nil { + return err + } + v := structPointer_BytesSlice(base, p.field) + *v = append(*v, b) + return nil +} + +// Decode a map field. +func (o *Buffer) dec_new_map(p *Properties, base structPointer) error { + raw, err := o.DecodeRawBytes(false) + if err != nil { + return err + } + oi := o.index // index at the end of this map entry + o.index -= len(raw) // move buffer back to start of map entry + + mptr := structPointer_NewAt(base, p.field, p.mtype) // *map[K]V + if mptr.Elem().IsNil() { + mptr.Elem().Set(reflect.MakeMap(mptr.Type().Elem())) + } + v := mptr.Elem() // map[K]V + + // Prepare addressable doubly-indirect placeholders for the key and value types. + // See enc_new_map for why. + keyptr := reflect.New(reflect.PtrTo(p.mtype.Key())).Elem() // addressable *K + keybase := toStructPointer(keyptr.Addr()) // **K + + var valbase structPointer + var valptr reflect.Value + switch p.mtype.Elem().Kind() { + case reflect.Slice: + // []byte + var dummy []byte + valptr = reflect.ValueOf(&dummy) // *[]byte + valbase = toStructPointer(valptr) // *[]byte + case reflect.Ptr: + // message; valptr is **Msg; need to allocate the intermediate pointer + valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V + valptr.Set(reflect.New(valptr.Type().Elem())) + valbase = toStructPointer(valptr) + default: + // everything else + valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V + valbase = toStructPointer(valptr.Addr()) // **V + } + + // Decode. + // This parses a restricted wire format, namely the encoding of a message + // with two fields. See enc_new_map for the format. + for o.index < oi { + // tagcode for key and value properties are always a single byte + // because they have tags 1 and 2. + tagcode := o.buf[o.index] + o.index++ + switch tagcode { + case p.mkeyprop.tagcode[0]: + if err := p.mkeyprop.dec(o, p.mkeyprop, keybase); err != nil { + return err + } + case p.mvalprop.tagcode[0]: + if err := p.mvalprop.dec(o, p.mvalprop, valbase); err != nil { + return err + } + default: + // TODO: Should we silently skip this instead? + return fmt.Errorf("proto: bad map data tag %d", raw[0]) + } + } + keyelem, valelem := keyptr.Elem(), valptr.Elem() + if !keyelem.IsValid() || !valelem.IsValid() { + // We did not decode the key or the value in the map entry. + // Either way, it's an invalid map entry. + return fmt.Errorf("proto: bad map data: missing key/val") + } + + v.SetMapIndex(keyelem, valelem) + return nil +} + +// Decode a group. +func (o *Buffer) dec_struct_group(p *Properties, base structPointer) error { + bas := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(bas) { + // allocate new nested message + bas = toStructPointer(reflect.New(p.stype)) + structPointer_SetStructPointer(base, p.field, bas) + } + return o.unmarshalType(p.stype, p.sprop, true, bas) +} + +// Decode an embedded message. +func (o *Buffer) dec_struct_message(p *Properties, base structPointer) (err error) { + raw, e := o.DecodeRawBytes(false) + if e != nil { + return e + } + + bas := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(bas) { + // allocate new nested message + bas = toStructPointer(reflect.New(p.stype)) + structPointer_SetStructPointer(base, p.field, bas) + } + + // If the object can unmarshal itself, let it. + if p.isUnmarshaler { + iv := structPointer_Interface(bas, p.stype) + return iv.(Unmarshaler).Unmarshal(raw) + } + + obuf := o.buf + oi := o.index + o.buf = raw + o.index = 0 + + err = o.unmarshalType(p.stype, p.sprop, false, bas) + o.buf = obuf + o.index = oi + + return err +} + +// Decode a slice of embedded messages. +func (o *Buffer) dec_slice_struct_message(p *Properties, base structPointer) error { + return o.dec_slice_struct(p, false, base) +} + +// Decode a slice of embedded groups. +func (o *Buffer) dec_slice_struct_group(p *Properties, base structPointer) error { + return o.dec_slice_struct(p, true, base) +} + +// Decode a slice of structs ([]*struct). +func (o *Buffer) dec_slice_struct(p *Properties, is_group bool, base structPointer) error { + v := reflect.New(p.stype) + bas := toStructPointer(v) + structPointer_StructPointerSlice(base, p.field).Append(bas) + + if is_group { + err := o.unmarshalType(p.stype, p.sprop, is_group, bas) + return err + } + + raw, err := o.DecodeRawBytes(false) + if err != nil { + return err + } + + // If the object can unmarshal itself, let it. + if p.isUnmarshaler { + iv := v.Interface() + return iv.(Unmarshaler).Unmarshal(raw) + } + + obuf := o.buf + oi := o.index + o.buf = raw + o.index = 0 + + err = o.unmarshalType(p.stype, p.sprop, is_group, bas) + + o.buf = obuf + o.index = oi + + return err +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/decode_gogo.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/decode_gogo.go new file mode 100644 index 0000000000000000000000000000000000000000..6a77aad7661a7650df4a37e6a429d269fbf540ef --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/decode_gogo.go @@ -0,0 +1,175 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 proto + +import ( + "reflect" +) + +// Decode a reference to a struct pointer. +func (o *Buffer) dec_ref_struct_message(p *Properties, base structPointer) (err error) { + raw, e := o.DecodeRawBytes(false) + if e != nil { + return e + } + + // If the object can unmarshal itself, let it. + if p.isUnmarshaler { + panic("not supported, since this is a pointer receiver") + } + + obuf := o.buf + oi := o.index + o.buf = raw + o.index = 0 + + bas := structPointer_FieldPointer(base, p.field) + + err = o.unmarshalType(p.stype, p.sprop, false, bas) + o.buf = obuf + o.index = oi + + return err +} + +// Decode a slice of references to struct pointers ([]struct). +func (o *Buffer) dec_slice_ref_struct(p *Properties, is_group bool, base structPointer) error { + newBas := appendStructPointer(base, p.field, p.sstype) + + if is_group { + panic("not supported, maybe in future, if requested.") + } + + raw, err := o.DecodeRawBytes(false) + if err != nil { + return err + } + + // If the object can unmarshal itself, let it. + if p.isUnmarshaler { + panic("not supported, since this is not a pointer receiver.") + } + + obuf := o.buf + oi := o.index + o.buf = raw + o.index = 0 + + err = o.unmarshalType(p.stype, p.sprop, is_group, newBas) + + o.buf = obuf + o.index = oi + + return err +} + +// Decode a slice of references to struct pointers. +func (o *Buffer) dec_slice_ref_struct_message(p *Properties, base structPointer) error { + return o.dec_slice_ref_struct(p, false, base) +} + +func setPtrCustomType(base structPointer, f field, v interface{}) { + if v == nil { + return + } + structPointer_SetStructPointer(base, f, structPointer(reflect.ValueOf(v).Pointer())) +} + +func setCustomType(base structPointer, f field, value interface{}) { + if value == nil { + return + } + v := reflect.ValueOf(value).Elem() + t := reflect.TypeOf(value).Elem() + kind := t.Kind() + switch kind { + case reflect.Slice: + slice := reflect.MakeSlice(t, v.Len(), v.Cap()) + reflect.Copy(slice, v) + oldHeader := structPointer_GetSliceHeader(base, f) + oldHeader.Data = slice.Pointer() + oldHeader.Len = v.Len() + oldHeader.Cap = v.Cap() + default: + l := 1 + size := reflect.TypeOf(value).Elem().Size() + if kind == reflect.Array { + l = reflect.TypeOf(value).Elem().Len() + size = reflect.TypeOf(value).Size() + } + total := int(size) * l + structPointer_Copy(toStructPointer(reflect.ValueOf(value)), structPointer_Add(base, f), total) + } +} + +func (o *Buffer) dec_custom_bytes(p *Properties, base structPointer) error { + b, err := o.DecodeRawBytes(true) + if err != nil { + return err + } + i := reflect.New(p.ctype.Elem()).Interface() + custom := (i).(Unmarshaler) + if err := custom.Unmarshal(b); err != nil { + return err + } + setPtrCustomType(base, p.field, custom) + return nil +} + +func (o *Buffer) dec_custom_ref_bytes(p *Properties, base structPointer) error { + b, err := o.DecodeRawBytes(true) + if err != nil { + return err + } + i := reflect.New(p.ctype).Interface() + custom := (i).(Unmarshaler) + if err := custom.Unmarshal(b); err != nil { + return err + } + if custom != nil { + setCustomType(base, p.field, custom) + } + return nil +} + +// Decode a slice of bytes ([]byte) into a slice of custom types. +func (o *Buffer) dec_custom_slice_bytes(p *Properties, base structPointer) error { + b, err := o.DecodeRawBytes(true) + if err != nil { + return err + } + i := reflect.New(p.ctype.Elem()).Interface() + custom := (i).(Unmarshaler) + if err := custom.Unmarshal(b); err != nil { + return err + } + newBas := appendStructPointer(base, p.field, p.ctype) + + setCustomType(newBas, 0, custom) + + return nil +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/encode.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/encode.go new file mode 100644 index 0000000000000000000000000000000000000000..89d0caa8268f5bcc106d542e4eeb35dbd5df7302 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/encode.go @@ -0,0 +1,1336 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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 proto + +/* + * Routines for encoding data into the wire format for protocol buffers. + */ + +import ( + "errors" + "fmt" + "reflect" + "sort" +) + +// RequiredNotSetError is the error returned if Marshal is called with +// a protocol buffer struct whose required fields have not +// all been initialized. It is also the error returned if Unmarshal is +// called with an encoded protocol buffer that does not include all the +// required fields. +// +// When printed, RequiredNotSetError reports the first unset required field in a +// message. If the field cannot be precisely determined, it is reported as +// "{Unknown}". +type RequiredNotSetError struct { + field string +} + +func (e *RequiredNotSetError) Error() string { + return fmt.Sprintf("proto: required field %q not set", e.field) +} + +var ( + // errRepeatedHasNil is the error returned if Marshal is called with + // a struct with a repeated field containing a nil element. + errRepeatedHasNil = errors.New("proto: repeated field has nil element") + + // ErrNil is the error returned if Marshal is called with nil. + ErrNil = errors.New("proto: Marshal called with nil") +) + +// The fundamental encoders that put bytes on the wire. +// Those that take integer types all accept uint64 and are +// therefore of type valueEncoder. + +const maxVarintBytes = 10 // maximum length of a varint + +// EncodeVarint returns the varint encoding of x. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +// Not used by the package itself, but helpful to clients +// wishing to use the same encoding. +func EncodeVarint(x uint64) []byte { + var buf [maxVarintBytes]byte + var n int + for n = 0; x > 127; n++ { + buf[n] = 0x80 | uint8(x&0x7F) + x >>= 7 + } + buf[n] = uint8(x) + n++ + return buf[0:n] +} + +// EncodeVarint writes a varint-encoded integer to the Buffer. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +func (p *Buffer) EncodeVarint(x uint64) error { + for x >= 1<<7 { + p.buf = append(p.buf, uint8(x&0x7f|0x80)) + x >>= 7 + } + p.buf = append(p.buf, uint8(x)) + return nil +} + +func sizeVarint(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} + +// EncodeFixed64 writes a 64-bit integer to the Buffer. +// This is the format for the +// fixed64, sfixed64, and double protocol buffer types. +func (p *Buffer) EncodeFixed64(x uint64) error { + p.buf = append(p.buf, + uint8(x), + uint8(x>>8), + uint8(x>>16), + uint8(x>>24), + uint8(x>>32), + uint8(x>>40), + uint8(x>>48), + uint8(x>>56)) + return nil +} + +func sizeFixed64(x uint64) int { + return 8 +} + +// EncodeFixed32 writes a 32-bit integer to the Buffer. +// This is the format for the +// fixed32, sfixed32, and float protocol buffer types. +func (p *Buffer) EncodeFixed32(x uint64) error { + p.buf = append(p.buf, + uint8(x), + uint8(x>>8), + uint8(x>>16), + uint8(x>>24)) + return nil +} + +func sizeFixed32(x uint64) int { + return 4 +} + +// EncodeZigzag64 writes a zigzag-encoded 64-bit integer +// to the Buffer. +// This is the format used for the sint64 protocol buffer type. +func (p *Buffer) EncodeZigzag64(x uint64) error { + // use signed number to get arithmetic right shift. + return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} + +func sizeZigzag64(x uint64) int { + return sizeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} + +// EncodeZigzag32 writes a zigzag-encoded 32-bit integer +// to the Buffer. +// This is the format used for the sint32 protocol buffer type. +func (p *Buffer) EncodeZigzag32(x uint64) error { + // use signed number to get arithmetic right shift. + return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31)))) +} + +func sizeZigzag32(x uint64) int { + return sizeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31)))) +} + +// EncodeRawBytes writes a count-delimited byte buffer to the Buffer. +// This is the format used for the bytes protocol buffer +// type and for embedded messages. +func (p *Buffer) EncodeRawBytes(b []byte) error { + p.EncodeVarint(uint64(len(b))) + p.buf = append(p.buf, b...) + return nil +} + +func sizeRawBytes(b []byte) int { + return sizeVarint(uint64(len(b))) + + len(b) +} + +// EncodeStringBytes writes an encoded string to the Buffer. +// This is the format used for the proto2 string type. +func (p *Buffer) EncodeStringBytes(s string) error { + p.EncodeVarint(uint64(len(s))) + p.buf = append(p.buf, s...) + return nil +} + +func sizeStringBytes(s string) int { + return sizeVarint(uint64(len(s))) + + len(s) +} + +// Marshaler is the interface representing objects that can marshal themselves. +type Marshaler interface { + Marshal() ([]byte, error) +} + +// Marshal takes the protocol buffer +// and encodes it into the wire format, returning the data. +func Marshal(pb Message) ([]byte, error) { + // Can the object marshal itself? + if m, ok := pb.(Marshaler); ok { + return m.Marshal() + } + p := NewBuffer(nil) + err := p.Marshal(pb) + var state errorState + if err != nil && !state.shouldContinue(err, nil) { + return nil, err + } + if p.buf == nil && err == nil { + // Return a non-nil slice on success. + return []byte{}, nil + } + return p.buf, err +} + +// EncodeMessage writes the protocol buffer to the Buffer, +// prefixed by a varint-encoded length. +func (p *Buffer) EncodeMessage(pb Message) error { + t, base, err := getbase(pb) + if structPointer_IsNil(base) { + return ErrNil + } + if err == nil { + var state errorState + err = p.enc_len_struct(GetProperties(t.Elem()), base, &state) + } + return err +} + +// Marshal takes the protocol buffer +// and encodes it into the wire format, writing the result to the +// Buffer. +func (p *Buffer) Marshal(pb Message) error { + // Can the object marshal itself? + if m, ok := pb.(Marshaler); ok { + data, err := m.Marshal() + if err != nil { + return err + } + p.buf = append(p.buf, data...) + return nil + } + + t, base, err := getbase(pb) + if structPointer_IsNil(base) { + return ErrNil + } + if err == nil { + err = p.enc_struct(GetProperties(t.Elem()), base) + } + + if collectStats { + stats.Encode++ + } + + return err +} + +// Size returns the encoded size of a protocol buffer. +func Size(pb Message) (n int) { + // Can the object marshal itself? If so, Size is slow. + // TODO: add Size to Marshaler, or add a Sizer interface. + if m, ok := pb.(Marshaler); ok { + b, _ := m.Marshal() + return len(b) + } + + t, base, err := getbase(pb) + if structPointer_IsNil(base) { + return 0 + } + if err == nil { + n = size_struct(GetProperties(t.Elem()), base) + } + + if collectStats { + stats.Size++ + } + + return +} + +// Individual type encoders. + +// Encode a bool. +func (o *Buffer) enc_bool(p *Properties, base structPointer) error { + v := *structPointer_Bool(base, p.field) + if v == nil { + return ErrNil + } + x := 0 + if *v { + x = 1 + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func (o *Buffer) enc_proto3_bool(p *Properties, base structPointer) error { + v := *structPointer_BoolVal(base, p.field) + if !v { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, 1) + return nil +} + +func size_bool(p *Properties, base structPointer) int { + v := *structPointer_Bool(base, p.field) + if v == nil { + return 0 + } + return len(p.tagcode) + 1 // each bool takes exactly one byte +} + +func size_proto3_bool(p *Properties, base structPointer) int { + v := *structPointer_BoolVal(base, p.field) + if !v && !p.oneof { + return 0 + } + return len(p.tagcode) + 1 // each bool takes exactly one byte +} + +// Encode an int32. +func (o *Buffer) enc_int32(p *Properties, base structPointer) error { + v := structPointer_Word32(base, p.field) + if word32_IsNil(v) { + return ErrNil + } + x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func (o *Buffer) enc_proto3_int32(p *Properties, base structPointer) error { + v := structPointer_Word32Val(base, p.field) + x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range + if x == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func size_int32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32(base, p.field) + if word32_IsNil(v) { + return 0 + } + x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +func size_proto3_int32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32Val(base, p.field) + x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range + if x == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +// Encode a uint32. +// Exactly the same as int32, except for no sign extension. +func (o *Buffer) enc_uint32(p *Properties, base structPointer) error { + v := structPointer_Word32(base, p.field) + if word32_IsNil(v) { + return ErrNil + } + x := word32_Get(v) + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func (o *Buffer) enc_proto3_uint32(p *Properties, base structPointer) error { + v := structPointer_Word32Val(base, p.field) + x := word32Val_Get(v) + if x == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func size_uint32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32(base, p.field) + if word32_IsNil(v) { + return 0 + } + x := word32_Get(v) + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +func size_proto3_uint32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32Val(base, p.field) + x := word32Val_Get(v) + if x == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +// Encode an int64. +func (o *Buffer) enc_int64(p *Properties, base structPointer) error { + v := structPointer_Word64(base, p.field) + if word64_IsNil(v) { + return ErrNil + } + x := word64_Get(v) + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, x) + return nil +} + +func (o *Buffer) enc_proto3_int64(p *Properties, base structPointer) error { + v := structPointer_Word64Val(base, p.field) + x := word64Val_Get(v) + if x == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, x) + return nil +} + +func size_int64(p *Properties, base structPointer) (n int) { + v := structPointer_Word64(base, p.field) + if word64_IsNil(v) { + return 0 + } + x := word64_Get(v) + n += len(p.tagcode) + n += p.valSize(x) + return +} + +func size_proto3_int64(p *Properties, base structPointer) (n int) { + v := structPointer_Word64Val(base, p.field) + x := word64Val_Get(v) + if x == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += p.valSize(x) + return +} + +// Encode a string. +func (o *Buffer) enc_string(p *Properties, base structPointer) error { + v := *structPointer_String(base, p.field) + if v == nil { + return ErrNil + } + x := *v + o.buf = append(o.buf, p.tagcode...) + o.EncodeStringBytes(x) + return nil +} + +func (o *Buffer) enc_proto3_string(p *Properties, base structPointer) error { + v := *structPointer_StringVal(base, p.field) + if v == "" { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeStringBytes(v) + return nil +} + +func size_string(p *Properties, base structPointer) (n int) { + v := *structPointer_String(base, p.field) + if v == nil { + return 0 + } + x := *v + n += len(p.tagcode) + n += sizeStringBytes(x) + return +} + +func size_proto3_string(p *Properties, base structPointer) (n int) { + v := *structPointer_StringVal(base, p.field) + if v == "" && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += sizeStringBytes(v) + return +} + +// All protocol buffer fields are nillable, but be careful. +func isNil(v reflect.Value) bool { + switch v.Kind() { + case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: + return v.IsNil() + } + return false +} + +// Encode a message struct. +func (o *Buffer) enc_struct_message(p *Properties, base structPointer) error { + var state errorState + structp := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(structp) { + return ErrNil + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, err := m.Marshal() + if err != nil && !state.shouldContinue(err, nil) { + return err + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + return state.err + } + + o.buf = append(o.buf, p.tagcode...) + return o.enc_len_struct(p.sprop, structp, &state) +} + +func size_struct_message(p *Properties, base structPointer) int { + structp := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(structp) { + return 0 + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, _ := m.Marshal() + n0 := len(p.tagcode) + n1 := sizeRawBytes(data) + return n0 + n1 + } + + n0 := len(p.tagcode) + n1 := size_struct(p.sprop, structp) + n2 := sizeVarint(uint64(n1)) // size of encoded length + return n0 + n1 + n2 +} + +// Encode a group struct. +func (o *Buffer) enc_struct_group(p *Properties, base structPointer) error { + var state errorState + b := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(b) { + return ErrNil + } + + o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup)) + err := o.enc_struct(p.sprop, b) + if err != nil && !state.shouldContinue(err, nil) { + return err + } + o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup)) + return state.err +} + +func size_struct_group(p *Properties, base structPointer) (n int) { + b := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(b) { + return 0 + } + + n += sizeVarint(uint64((p.Tag << 3) | WireStartGroup)) + n += size_struct(p.sprop, b) + n += sizeVarint(uint64((p.Tag << 3) | WireEndGroup)) + return +} + +// Encode a slice of bools ([]bool). +func (o *Buffer) enc_slice_bool(p *Properties, base structPointer) error { + s := *structPointer_BoolSlice(base, p.field) + l := len(s) + if l == 0 { + return ErrNil + } + for _, x := range s { + o.buf = append(o.buf, p.tagcode...) + v := uint64(0) + if x { + v = 1 + } + p.valEnc(o, v) + } + return nil +} + +func size_slice_bool(p *Properties, base structPointer) int { + s := *structPointer_BoolSlice(base, p.field) + l := len(s) + if l == 0 { + return 0 + } + return l * (len(p.tagcode) + 1) // each bool takes exactly one byte +} + +// Encode a slice of bools ([]bool) in packed format. +func (o *Buffer) enc_slice_packed_bool(p *Properties, base structPointer) error { + s := *structPointer_BoolSlice(base, p.field) + l := len(s) + if l == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeVarint(uint64(l)) // each bool takes exactly one byte + for _, x := range s { + v := uint64(0) + if x { + v = 1 + } + p.valEnc(o, v) + } + return nil +} + +func size_slice_packed_bool(p *Properties, base structPointer) (n int) { + s := *structPointer_BoolSlice(base, p.field) + l := len(s) + if l == 0 { + return 0 + } + n += len(p.tagcode) + n += sizeVarint(uint64(l)) + n += l // each bool takes exactly one byte + return +} + +// Encode a slice of bytes ([]byte). +func (o *Buffer) enc_slice_byte(p *Properties, base structPointer) error { + s := *structPointer_Bytes(base, p.field) + if s == nil { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(s) + return nil +} + +func (o *Buffer) enc_proto3_slice_byte(p *Properties, base structPointer) error { + s := *structPointer_Bytes(base, p.field) + if len(s) == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(s) + return nil +} + +func size_slice_byte(p *Properties, base structPointer) (n int) { + s := *structPointer_Bytes(base, p.field) + if s == nil && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += sizeRawBytes(s) + return +} + +func size_proto3_slice_byte(p *Properties, base structPointer) (n int) { + s := *structPointer_Bytes(base, p.field) + if len(s) == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += sizeRawBytes(s) + return +} + +// Encode a slice of int32s ([]int32). +func (o *Buffer) enc_slice_int32(p *Properties, base structPointer) error { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + x := int32(s.Index(i)) // permit sign extension to use full 64-bit range + p.valEnc(o, uint64(x)) + } + return nil +} + +func size_slice_int32(p *Properties, base structPointer) (n int) { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + for i := 0; i < l; i++ { + n += len(p.tagcode) + x := int32(s.Index(i)) // permit sign extension to use full 64-bit range + n += p.valSize(uint64(x)) + } + return +} + +// Encode a slice of int32s ([]int32) in packed format. +func (o *Buffer) enc_slice_packed_int32(p *Properties, base structPointer) error { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + // TODO: Reuse a Buffer. + buf := NewBuffer(nil) + for i := 0; i < l; i++ { + x := int32(s.Index(i)) // permit sign extension to use full 64-bit range + p.valEnc(buf, uint64(x)) + } + + o.buf = append(o.buf, p.tagcode...) + o.EncodeVarint(uint64(len(buf.buf))) + o.buf = append(o.buf, buf.buf...) + return nil +} + +func size_slice_packed_int32(p *Properties, base structPointer) (n int) { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + var bufSize int + for i := 0; i < l; i++ { + x := int32(s.Index(i)) // permit sign extension to use full 64-bit range + bufSize += p.valSize(uint64(x)) + } + + n += len(p.tagcode) + n += sizeVarint(uint64(bufSize)) + n += bufSize + return +} + +// Encode a slice of uint32s ([]uint32). +// Exactly the same as int32, except for no sign extension. +func (o *Buffer) enc_slice_uint32(p *Properties, base structPointer) error { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + x := s.Index(i) + p.valEnc(o, uint64(x)) + } + return nil +} + +func size_slice_uint32(p *Properties, base structPointer) (n int) { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + for i := 0; i < l; i++ { + n += len(p.tagcode) + x := s.Index(i) + n += p.valSize(uint64(x)) + } + return +} + +// Encode a slice of uint32s ([]uint32) in packed format. +// Exactly the same as int32, except for no sign extension. +func (o *Buffer) enc_slice_packed_uint32(p *Properties, base structPointer) error { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + // TODO: Reuse a Buffer. + buf := NewBuffer(nil) + for i := 0; i < l; i++ { + p.valEnc(buf, uint64(s.Index(i))) + } + + o.buf = append(o.buf, p.tagcode...) + o.EncodeVarint(uint64(len(buf.buf))) + o.buf = append(o.buf, buf.buf...) + return nil +} + +func size_slice_packed_uint32(p *Properties, base structPointer) (n int) { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + var bufSize int + for i := 0; i < l; i++ { + bufSize += p.valSize(uint64(s.Index(i))) + } + + n += len(p.tagcode) + n += sizeVarint(uint64(bufSize)) + n += bufSize + return +} + +// Encode a slice of int64s ([]int64). +func (o *Buffer) enc_slice_int64(p *Properties, base structPointer) error { + s := structPointer_Word64Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, s.Index(i)) + } + return nil +} + +func size_slice_int64(p *Properties, base structPointer) (n int) { + s := structPointer_Word64Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + for i := 0; i < l; i++ { + n += len(p.tagcode) + n += p.valSize(s.Index(i)) + } + return +} + +// Encode a slice of int64s ([]int64) in packed format. +func (o *Buffer) enc_slice_packed_int64(p *Properties, base structPointer) error { + s := structPointer_Word64Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + // TODO: Reuse a Buffer. + buf := NewBuffer(nil) + for i := 0; i < l; i++ { + p.valEnc(buf, s.Index(i)) + } + + o.buf = append(o.buf, p.tagcode...) + o.EncodeVarint(uint64(len(buf.buf))) + o.buf = append(o.buf, buf.buf...) + return nil +} + +func size_slice_packed_int64(p *Properties, base structPointer) (n int) { + s := structPointer_Word64Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + var bufSize int + for i := 0; i < l; i++ { + bufSize += p.valSize(s.Index(i)) + } + + n += len(p.tagcode) + n += sizeVarint(uint64(bufSize)) + n += bufSize + return +} + +// Encode a slice of slice of bytes ([][]byte). +func (o *Buffer) enc_slice_slice_byte(p *Properties, base structPointer) error { + ss := *structPointer_BytesSlice(base, p.field) + l := len(ss) + if l == 0 { + return ErrNil + } + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(ss[i]) + } + return nil +} + +func size_slice_slice_byte(p *Properties, base structPointer) (n int) { + ss := *structPointer_BytesSlice(base, p.field) + l := len(ss) + if l == 0 { + return 0 + } + n += l * len(p.tagcode) + for i := 0; i < l; i++ { + n += sizeRawBytes(ss[i]) + } + return +} + +// Encode a slice of strings ([]string). +func (o *Buffer) enc_slice_string(p *Properties, base structPointer) error { + ss := *structPointer_StringSlice(base, p.field) + l := len(ss) + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + o.EncodeStringBytes(ss[i]) + } + return nil +} + +func size_slice_string(p *Properties, base structPointer) (n int) { + ss := *structPointer_StringSlice(base, p.field) + l := len(ss) + n += l * len(p.tagcode) + for i := 0; i < l; i++ { + n += sizeStringBytes(ss[i]) + } + return +} + +// Encode a slice of message structs ([]*struct). +func (o *Buffer) enc_slice_struct_message(p *Properties, base structPointer) error { + var state errorState + s := structPointer_StructPointerSlice(base, p.field) + l := s.Len() + + for i := 0; i < l; i++ { + structp := s.Index(i) + if structPointer_IsNil(structp) { + return errRepeatedHasNil + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, err := m.Marshal() + if err != nil && !state.shouldContinue(err, nil) { + return err + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + continue + } + + o.buf = append(o.buf, p.tagcode...) + err := o.enc_len_struct(p.sprop, structp, &state) + if err != nil && !state.shouldContinue(err, nil) { + if err == ErrNil { + return errRepeatedHasNil + } + return err + } + } + return state.err +} + +func size_slice_struct_message(p *Properties, base structPointer) (n int) { + s := structPointer_StructPointerSlice(base, p.field) + l := s.Len() + n += l * len(p.tagcode) + for i := 0; i < l; i++ { + structp := s.Index(i) + if structPointer_IsNil(structp) { + return // return the size up to this point + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, _ := m.Marshal() + n += len(p.tagcode) + n += sizeRawBytes(data) + continue + } + + n0 := size_struct(p.sprop, structp) + n1 := sizeVarint(uint64(n0)) // size of encoded length + n += n0 + n1 + } + return +} + +// Encode a slice of group structs ([]*struct). +func (o *Buffer) enc_slice_struct_group(p *Properties, base structPointer) error { + var state errorState + s := structPointer_StructPointerSlice(base, p.field) + l := s.Len() + + for i := 0; i < l; i++ { + b := s.Index(i) + if structPointer_IsNil(b) { + return errRepeatedHasNil + } + + o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup)) + + err := o.enc_struct(p.sprop, b) + + if err != nil && !state.shouldContinue(err, nil) { + if err == ErrNil { + return errRepeatedHasNil + } + return err + } + + o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup)) + } + return state.err +} + +func size_slice_struct_group(p *Properties, base structPointer) (n int) { + s := structPointer_StructPointerSlice(base, p.field) + l := s.Len() + + n += l * sizeVarint(uint64((p.Tag<<3)|WireStartGroup)) + n += l * sizeVarint(uint64((p.Tag<<3)|WireEndGroup)) + for i := 0; i < l; i++ { + b := s.Index(i) + if structPointer_IsNil(b) { + return // return size up to this point + } + + n += size_struct(p.sprop, b) + } + return +} + +// Encode an extension map. +func (o *Buffer) enc_map(p *Properties, base structPointer) error { + v := *structPointer_ExtMap(base, p.field) + if err := encodeExtensionMap(v); err != nil { + return err + } + // Fast-path for common cases: zero or one extensions. + if len(v) <= 1 { + for _, e := range v { + o.buf = append(o.buf, e.enc...) + } + return nil + } + + // Sort keys to provide a deterministic encoding. + keys := make([]int, 0, len(v)) + for k := range v { + keys = append(keys, int(k)) + } + sort.Ints(keys) + + for _, k := range keys { + o.buf = append(o.buf, v[int32(k)].enc...) + } + return nil +} + +func size_map(p *Properties, base structPointer) int { + v := *structPointer_ExtMap(base, p.field) + return sizeExtensionMap(v) +} + +// Encode a map field. +func (o *Buffer) enc_new_map(p *Properties, base structPointer) error { + var state errorState // XXX: or do we need to plumb this through? + + /* + A map defined as + map map_field = N; + is encoded in the same way as + message MapFieldEntry { + key_type key = 1; + value_type value = 2; + } + repeated MapFieldEntry map_field = N; + */ + + v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V + if v.Len() == 0 { + return nil + } + + keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype) + + enc := func() error { + if err := p.mkeyprop.enc(o, p.mkeyprop, keybase); err != nil { + return err + } + if err := p.mvalprop.enc(o, p.mvalprop, valbase); err != nil { + return err + } + return nil + } + + keys := v.MapKeys() + sort.Sort(mapKeys(keys)) + for _, key := range keys { + val := v.MapIndex(key) + + // The only illegal map entry values are nil message pointers. + if val.Kind() == reflect.Ptr && val.IsNil() { + return errors.New("proto: map has nil element") + } + + keycopy.Set(key) + valcopy.Set(val) + + o.buf = append(o.buf, p.tagcode...) + if err := o.enc_len_thing(enc, &state); err != nil { + return err + } + } + return nil +} + +func size_new_map(p *Properties, base structPointer) int { + v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V + + keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype) + + n := 0 + for _, key := range v.MapKeys() { + val := v.MapIndex(key) + keycopy.Set(key) + valcopy.Set(val) + + // Tag codes for key and val are the responsibility of the sub-sizer. + keysize := p.mkeyprop.size(p.mkeyprop, keybase) + valsize := p.mvalprop.size(p.mvalprop, valbase) + entry := keysize + valsize + // Add on tag code and length of map entry itself. + n += len(p.tagcode) + sizeVarint(uint64(entry)) + entry + } + return n +} + +// mapEncodeScratch returns a new reflect.Value matching the map's value type, +// and a structPointer suitable for passing to an encoder or sizer. +func mapEncodeScratch(mapType reflect.Type) (keycopy, valcopy reflect.Value, keybase, valbase structPointer) { + // Prepare addressable doubly-indirect placeholders for the key and value types. + // This is needed because the element-type encoders expect **T, but the map iteration produces T. + + keycopy = reflect.New(mapType.Key()).Elem() // addressable K + keyptr := reflect.New(reflect.PtrTo(keycopy.Type())).Elem() // addressable *K + keyptr.Set(keycopy.Addr()) // + keybase = toStructPointer(keyptr.Addr()) // **K + + // Value types are more varied and require special handling. + switch mapType.Elem().Kind() { + case reflect.Slice: + // []byte + var dummy []byte + valcopy = reflect.ValueOf(&dummy).Elem() // addressable []byte + valbase = toStructPointer(valcopy.Addr()) + case reflect.Ptr: + // message; the generated field type is map[K]*Msg (so V is *Msg), + // so we only need one level of indirection. + valcopy = reflect.New(mapType.Elem()).Elem() // addressable V + valbase = toStructPointer(valcopy.Addr()) + default: + // everything else + valcopy = reflect.New(mapType.Elem()).Elem() // addressable V + valptr := reflect.New(reflect.PtrTo(valcopy.Type())).Elem() // addressable *V + valptr.Set(valcopy.Addr()) // + valbase = toStructPointer(valptr.Addr()) // **V + } + return +} + +// Encode a struct. +func (o *Buffer) enc_struct(prop *StructProperties, base structPointer) error { + var state errorState + // Encode fields in tag order so that decoders may use optimizations + // that depend on the ordering. + // https://developers.google.com/protocol-buffers/docs/encoding#order + for _, i := range prop.order { + p := prop.Prop[i] + if p.enc != nil { + err := p.enc(o, p, base) + if err != nil { + if err == ErrNil { + if p.Required && state.err == nil { + state.err = &RequiredNotSetError{p.Name} + } + } else if err == errRepeatedHasNil { + // Give more context to nil values in repeated fields. + return errors.New("repeated field " + p.OrigName + " has nil element") + } else if !state.shouldContinue(err, p) { + return err + } + } + } + } + + // Do oneof fields. + if prop.oneofMarshaler != nil { + m := structPointer_Interface(base, prop.stype).(Message) + if err := prop.oneofMarshaler(m, o); err != nil { + return err + } + } + + // Add unrecognized fields at the end. + if prop.unrecField.IsValid() { + v := *structPointer_Bytes(base, prop.unrecField) + if len(v) > 0 { + o.buf = append(o.buf, v...) + } + } + + return state.err +} + +func size_struct(prop *StructProperties, base structPointer) (n int) { + for _, i := range prop.order { + p := prop.Prop[i] + if p.size != nil { + n += p.size(p, base) + } + } + + // Add unrecognized fields at the end. + if prop.unrecField.IsValid() { + v := *structPointer_Bytes(base, prop.unrecField) + n += len(v) + } + + // Factor in any oneof fields. + // TODO: This could be faster and use less reflection. + if prop.oneofMarshaler != nil { + sv := reflect.ValueOf(structPointer_Interface(base, prop.stype)).Elem() + for i := 0; i < prop.stype.NumField(); i++ { + fv := sv.Field(i) + if fv.Kind() != reflect.Interface || fv.IsNil() { + continue + } + if prop.stype.Field(i).Tag.Get("protobuf_oneof") == "" { + continue + } + spv := fv.Elem() // interface -> *T + sv := spv.Elem() // *T -> T + sf := sv.Type().Field(0) // StructField inside T + var prop Properties + prop.Init(sf.Type, "whatever", sf.Tag.Get("protobuf"), &sf) + n += prop.size(&prop, toStructPointer(spv)) + } + } + + return +} + +var zeroes [20]byte // longer than any conceivable sizeVarint + +// Encode a struct, preceded by its encoded length (as a varint). +func (o *Buffer) enc_len_struct(prop *StructProperties, base structPointer, state *errorState) error { + return o.enc_len_thing(func() error { return o.enc_struct(prop, base) }, state) +} + +// Encode something, preceded by its encoded length (as a varint). +func (o *Buffer) enc_len_thing(enc func() error, state *errorState) error { + iLen := len(o.buf) + o.buf = append(o.buf, 0, 0, 0, 0) // reserve four bytes for length + iMsg := len(o.buf) + err := enc() + if err != nil && !state.shouldContinue(err, nil) { + return err + } + lMsg := len(o.buf) - iMsg + lLen := sizeVarint(uint64(lMsg)) + switch x := lLen - (iMsg - iLen); { + case x > 0: // actual length is x bytes larger than the space we reserved + // Move msg x bytes right. + o.buf = append(o.buf, zeroes[:x]...) + copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg]) + case x < 0: // actual length is x bytes smaller than the space we reserved + // Move msg x bytes left. + copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg]) + o.buf = o.buf[:len(o.buf)+x] // x is negative + } + // Encode the length in the reserved space. + o.buf = o.buf[:iLen] + o.EncodeVarint(uint64(lMsg)) + o.buf = o.buf[:len(o.buf)+lMsg] + return state.err +} + +// errorState maintains the first error that occurs and updates that error +// with additional context. +type errorState struct { + err error +} + +// shouldContinue reports whether encoding should continue upon encountering the +// given error. If the error is RequiredNotSetError, shouldContinue returns true +// and, if this is the first appearance of that error, remembers it for future +// reporting. +// +// If prop is not nil, it may update any error with additional context about the +// field with the error. +func (s *errorState) shouldContinue(err error, prop *Properties) bool { + // Ignore unset required fields. + reqNotSet, ok := err.(*RequiredNotSetError) + if !ok { + return false + } + if s.err == nil { + if prop != nil { + err = &RequiredNotSetError{prop.Name + "." + reqNotSet.field} + } + s.err = err + } + return true +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/encode_gogo.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/encode_gogo.go new file mode 100644 index 0000000000000000000000000000000000000000..f77cfb1eea4dbc5a75ae2c68b293970b3a315502 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/encode_gogo.go @@ -0,0 +1,354 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// http://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 proto + +import ( + "reflect" +) + +func NewRequiredNotSetError(field string) *RequiredNotSetError { + return &RequiredNotSetError{field} +} + +type Sizer interface { + Size() int +} + +func (o *Buffer) enc_ext_slice_byte(p *Properties, base structPointer) error { + s := *structPointer_Bytes(base, p.field) + if s == nil { + return ErrNil + } + o.buf = append(o.buf, s...) + return nil +} + +func size_ext_slice_byte(p *Properties, base structPointer) (n int) { + s := *structPointer_Bytes(base, p.field) + if s == nil { + return 0 + } + n += len(s) + return +} + +// Encode a reference to bool pointer. +func (o *Buffer) enc_ref_bool(p *Properties, base structPointer) error { + v := *structPointer_BoolVal(base, p.field) + x := 0 + if v { + x = 1 + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func size_ref_bool(p *Properties, base structPointer) int { + return len(p.tagcode) + 1 // each bool takes exactly one byte +} + +// Encode a reference to int32 pointer. +func (o *Buffer) enc_ref_int32(p *Properties, base structPointer) error { + v := structPointer_Word32Val(base, p.field) + x := int32(word32Val_Get(v)) + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func size_ref_int32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32Val(base, p.field) + x := int32(word32Val_Get(v)) + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +func (o *Buffer) enc_ref_uint32(p *Properties, base structPointer) error { + v := structPointer_Word32Val(base, p.field) + x := word32Val_Get(v) + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func size_ref_uint32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32Val(base, p.field) + x := word32Val_Get(v) + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +// Encode a reference to an int64 pointer. +func (o *Buffer) enc_ref_int64(p *Properties, base structPointer) error { + v := structPointer_Word64Val(base, p.field) + x := word64Val_Get(v) + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, x) + return nil +} + +func size_ref_int64(p *Properties, base structPointer) (n int) { + v := structPointer_Word64Val(base, p.field) + x := word64Val_Get(v) + n += len(p.tagcode) + n += p.valSize(x) + return +} + +// Encode a reference to a string pointer. +func (o *Buffer) enc_ref_string(p *Properties, base structPointer) error { + v := *structPointer_StringVal(base, p.field) + o.buf = append(o.buf, p.tagcode...) + o.EncodeStringBytes(v) + return nil +} + +func size_ref_string(p *Properties, base structPointer) (n int) { + v := *structPointer_StringVal(base, p.field) + n += len(p.tagcode) + n += sizeStringBytes(v) + return +} + +// Encode a reference to a message struct. +func (o *Buffer) enc_ref_struct_message(p *Properties, base structPointer) error { + var state errorState + structp := structPointer_GetRefStructPointer(base, p.field) + if structPointer_IsNil(structp) { + return ErrNil + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, err := m.Marshal() + if err != nil && !state.shouldContinue(err, nil) { + return err + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + return nil + } + + o.buf = append(o.buf, p.tagcode...) + return o.enc_len_struct(p.sprop, structp, &state) +} + +//TODO this is only copied, please fix this +func size_ref_struct_message(p *Properties, base structPointer) int { + structp := structPointer_GetRefStructPointer(base, p.field) + if structPointer_IsNil(structp) { + return 0 + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, _ := m.Marshal() + n0 := len(p.tagcode) + n1 := sizeRawBytes(data) + return n0 + n1 + } + + n0 := len(p.tagcode) + n1 := size_struct(p.sprop, structp) + n2 := sizeVarint(uint64(n1)) // size of encoded length + return n0 + n1 + n2 +} + +// Encode a slice of references to message struct pointers ([]struct). +func (o *Buffer) enc_slice_ref_struct_message(p *Properties, base structPointer) error { + var state errorState + ss := structPointer_GetStructPointer(base, p.field) + ss1 := structPointer_GetRefStructPointer(ss, field(0)) + size := p.stype.Size() + l := structPointer_Len(base, p.field) + for i := 0; i < l; i++ { + structp := structPointer_Add(ss1, field(uintptr(i)*size)) + if structPointer_IsNil(structp) { + return errRepeatedHasNil + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, err := m.Marshal() + if err != nil && !state.shouldContinue(err, nil) { + return err + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + continue + } + + o.buf = append(o.buf, p.tagcode...) + err := o.enc_len_struct(p.sprop, structp, &state) + if err != nil && !state.shouldContinue(err, nil) { + if err == ErrNil { + return errRepeatedHasNil + } + return err + } + + } + return state.err +} + +//TODO this is only copied, please fix this +func size_slice_ref_struct_message(p *Properties, base structPointer) (n int) { + ss := structPointer_GetStructPointer(base, p.field) + ss1 := structPointer_GetRefStructPointer(ss, field(0)) + size := p.stype.Size() + l := structPointer_Len(base, p.field) + n += l * len(p.tagcode) + for i := 0; i < l; i++ { + structp := structPointer_Add(ss1, field(uintptr(i)*size)) + if structPointer_IsNil(structp) { + return // return the size up to this point + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, _ := m.Marshal() + n += len(p.tagcode) + n += sizeRawBytes(data) + continue + } + + n0 := size_struct(p.sprop, structp) + n1 := sizeVarint(uint64(n0)) // size of encoded length + n += n0 + n1 + } + return +} + +func (o *Buffer) enc_custom_bytes(p *Properties, base structPointer) error { + i := structPointer_InterfaceRef(base, p.field, p.ctype) + if i == nil { + return ErrNil + } + custom := i.(Marshaler) + data, err := custom.Marshal() + if err != nil { + return err + } + if data == nil { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + return nil +} + +func size_custom_bytes(p *Properties, base structPointer) (n int) { + n += len(p.tagcode) + i := structPointer_InterfaceRef(base, p.field, p.ctype) + if i == nil { + return 0 + } + custom := i.(Marshaler) + data, _ := custom.Marshal() + n += sizeRawBytes(data) + return +} + +func (o *Buffer) enc_custom_ref_bytes(p *Properties, base structPointer) error { + custom := structPointer_InterfaceAt(base, p.field, p.ctype).(Marshaler) + data, err := custom.Marshal() + if err != nil { + return err + } + if data == nil { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + return nil +} + +func size_custom_ref_bytes(p *Properties, base structPointer) (n int) { + n += len(p.tagcode) + i := structPointer_InterfaceAt(base, p.field, p.ctype) + if i == nil { + return 0 + } + custom := i.(Marshaler) + data, _ := custom.Marshal() + n += sizeRawBytes(data) + return +} + +func (o *Buffer) enc_custom_slice_bytes(p *Properties, base structPointer) error { + inter := structPointer_InterfaceRef(base, p.field, p.ctype) + if inter == nil { + return ErrNil + } + slice := reflect.ValueOf(inter) + l := slice.Len() + for i := 0; i < l; i++ { + v := slice.Index(i) + custom := v.Interface().(Marshaler) + data, err := custom.Marshal() + if err != nil { + return err + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + } + return nil +} + +func size_custom_slice_bytes(p *Properties, base structPointer) (n int) { + inter := structPointer_InterfaceRef(base, p.field, p.ctype) + if inter == nil { + return 0 + } + slice := reflect.ValueOf(inter) + l := slice.Len() + n += l * len(p.tagcode) + for i := 0; i < l; i++ { + v := slice.Index(i) + custom := v.Interface().(Marshaler) + data, _ := custom.Marshal() + n += sizeRawBytes(data) + } + return +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/equal.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/equal.go new file mode 100644 index 0000000000000000000000000000000000000000..5475c3d9596f47ec658744119fdd3d678af2cc9f --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/equal.go @@ -0,0 +1,267 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2011 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. + +// Protocol buffer comparison. +// TODO: MessageSet. + +package proto + +import ( + "bytes" + "log" + "reflect" + "strings" +) + +/* +Equal returns true iff protocol buffers a and b are equal. +The arguments must both be pointers to protocol buffer structs. + +Equality is defined in this way: + - Two messages are equal iff they are the same type, + corresponding fields are equal, unknown field sets + are equal, and extensions sets are equal. + - Two set scalar fields are equal iff their values are equal. + If the fields are of a floating-point type, remember that + NaN != x for all x, including NaN. + - Two repeated fields are equal iff their lengths are the same, + and their corresponding elements are equal (a "bytes" field, + although represented by []byte, is not a repeated field) + - Two unset fields are equal. + - Two unknown field sets are equal if their current + encoded state is equal. + - Two extension sets are equal iff they have corresponding + elements that are pairwise equal. + - Every other combination of things are not equal. + +The return value is undefined if a and b are not protocol buffers. +*/ +func Equal(a, b Message) bool { + if a == nil || b == nil { + return a == b + } + v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b) + if v1.Type() != v2.Type() { + return false + } + if v1.Kind() == reflect.Ptr { + if v1.IsNil() { + return v2.IsNil() + } + if v2.IsNil() { + return false + } + v1, v2 = v1.Elem(), v2.Elem() + } + if v1.Kind() != reflect.Struct { + return false + } + return equalStruct(v1, v2) +} + +// v1 and v2 are known to have the same type. +func equalStruct(v1, v2 reflect.Value) bool { + for i := 0; i < v1.NumField(); i++ { + f := v1.Type().Field(i) + if strings.HasPrefix(f.Name, "XXX_") { + continue + } + f1, f2 := v1.Field(i), v2.Field(i) + if f.Type.Kind() == reflect.Ptr { + if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 { + // both unset + continue + } else if n1 != n2 { + // set/unset mismatch + return false + } + b1, ok := f1.Interface().(raw) + if ok { + b2 := f2.Interface().(raw) + // RawMessage + if !bytes.Equal(b1.Bytes(), b2.Bytes()) { + return false + } + continue + } + f1, f2 = f1.Elem(), f2.Elem() + } + if !equalAny(f1, f2) { + return false + } + } + + if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() { + em2 := v2.FieldByName("XXX_extensions") + if !equalExtensions(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) { + return false + } + } + + uf := v1.FieldByName("XXX_unrecognized") + if !uf.IsValid() { + return true + } + + u1 := uf.Bytes() + u2 := v2.FieldByName("XXX_unrecognized").Bytes() + if !bytes.Equal(u1, u2) { + return false + } + + return true +} + +// v1 and v2 are known to have the same type. +func equalAny(v1, v2 reflect.Value) bool { + if v1.Type() == protoMessageType { + m1, _ := v1.Interface().(Message) + m2, _ := v2.Interface().(Message) + return Equal(m1, m2) + } + switch v1.Kind() { + case reflect.Bool: + return v1.Bool() == v2.Bool() + case reflect.Float32, reflect.Float64: + return v1.Float() == v2.Float() + case reflect.Int32, reflect.Int64: + return v1.Int() == v2.Int() + case reflect.Interface: + // Probably a oneof field; compare the inner values. + n1, n2 := v1.IsNil(), v2.IsNil() + if n1 || n2 { + return n1 == n2 + } + e1, e2 := v1.Elem(), v2.Elem() + if e1.Type() != e2.Type() { + return false + } + return equalAny(e1, e2) + case reflect.Map: + if v1.Len() != v2.Len() { + return false + } + for _, key := range v1.MapKeys() { + val2 := v2.MapIndex(key) + if !val2.IsValid() { + // This key was not found in the second map. + return false + } + if !equalAny(v1.MapIndex(key), val2) { + return false + } + } + return true + case reflect.Ptr: + return equalAny(v1.Elem(), v2.Elem()) + case reflect.Slice: + if v1.Type().Elem().Kind() == reflect.Uint8 { + // short circuit: []byte + if v1.IsNil() != v2.IsNil() { + return false + } + return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte)) + } + + if v1.Len() != v2.Len() { + return false + } + for i := 0; i < v1.Len(); i++ { + if !equalAny(v1.Index(i), v2.Index(i)) { + return false + } + } + return true + case reflect.String: + return v1.Interface().(string) == v2.Interface().(string) + case reflect.Struct: + return equalStruct(v1, v2) + case reflect.Uint32, reflect.Uint64: + return v1.Uint() == v2.Uint() + } + + // unknown type, so not a protocol buffer + log.Printf("proto: don't know how to compare %v", v1) + return false +} + +// base is the struct type that the extensions are based on. +// em1 and em2 are extension maps. +func equalExtensions(base reflect.Type, em1, em2 map[int32]Extension) bool { + if len(em1) != len(em2) { + return false + } + + for extNum, e1 := range em1 { + e2, ok := em2[extNum] + if !ok { + return false + } + + m1, m2 := e1.value, e2.value + + if m1 != nil && m2 != nil { + // Both are unencoded. + if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2)) { + return false + } + continue + } + + // At least one is encoded. To do a semantically correct comparison + // we need to unmarshal them first. + var desc *ExtensionDesc + if m := extensionMaps[base]; m != nil { + desc = m[extNum] + } + if desc == nil { + log.Printf("proto: don't know how to compare extension %d of %v", extNum, base) + continue + } + var err error + if m1 == nil { + m1, err = decodeExtension(e1.enc, desc) + } + if m2 == nil && err == nil { + m2, err = decodeExtension(e2.enc, desc) + } + if err != nil { + // The encoded form is invalid. + log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err) + return false + } + if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2)) { + return false + } + } + + return true +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/equal_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/equal_test.go new file mode 100644 index 0000000000000000000000000000000000000000..0df71c0074fd50e568b445fbb36f781ff92a2e18 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/equal_test.go @@ -0,0 +1,209 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2011 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 proto_test + +import ( + "testing" + + . "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + pb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata" +) + +// Four identical base messages. +// The init function adds extensions to some of them. +var messageWithoutExtension = &pb.MyMessage{Count: Int32(7)} +var messageWithExtension1a = &pb.MyMessage{Count: Int32(7)} +var messageWithExtension1b = &pb.MyMessage{Count: Int32(7)} +var messageWithExtension2 = &pb.MyMessage{Count: Int32(7)} + +// Two messages with non-message extensions. +var messageWithInt32Extension1 = &pb.MyMessage{Count: Int32(8)} +var messageWithInt32Extension2 = &pb.MyMessage{Count: Int32(8)} + +func init() { + ext1 := &pb.Ext{Data: String("Kirk")} + ext2 := &pb.Ext{Data: String("Picard")} + + // messageWithExtension1a has ext1, but never marshals it. + if err := SetExtension(messageWithExtension1a, pb.E_Ext_More, ext1); err != nil { + panic("SetExtension on 1a failed: " + err.Error()) + } + + // messageWithExtension1b is the unmarshaled form of messageWithExtension1a. + if err := SetExtension(messageWithExtension1b, pb.E_Ext_More, ext1); err != nil { + panic("SetExtension on 1b failed: " + err.Error()) + } + buf, err := Marshal(messageWithExtension1b) + if err != nil { + panic("Marshal of 1b failed: " + err.Error()) + } + messageWithExtension1b.Reset() + if err := Unmarshal(buf, messageWithExtension1b); err != nil { + panic("Unmarshal of 1b failed: " + err.Error()) + } + + // messageWithExtension2 has ext2. + if err := SetExtension(messageWithExtension2, pb.E_Ext_More, ext2); err != nil { + panic("SetExtension on 2 failed: " + err.Error()) + } + + if err := SetExtension(messageWithInt32Extension1, pb.E_Ext_Number, Int32(23)); err != nil { + panic("SetExtension on Int32-1 failed: " + err.Error()) + } + if err := SetExtension(messageWithInt32Extension1, pb.E_Ext_Number, Int32(24)); err != nil { + panic("SetExtension on Int32-2 failed: " + err.Error()) + } +} + +var EqualTests = []struct { + desc string + a, b Message + exp bool +}{ + {"different types", &pb.GoEnum{}, &pb.GoTestField{}, false}, + {"equal empty", &pb.GoEnum{}, &pb.GoEnum{}, true}, + {"nil vs nil", nil, nil, true}, + {"typed nil vs typed nil", (*pb.GoEnum)(nil), (*pb.GoEnum)(nil), true}, + {"typed nil vs empty", (*pb.GoEnum)(nil), &pb.GoEnum{}, false}, + {"different typed nil", (*pb.GoEnum)(nil), (*pb.GoTestField)(nil), false}, + + {"one set field, one unset field", &pb.GoTestField{Label: String("foo")}, &pb.GoTestField{}, false}, + {"one set field zero, one unset field", &pb.GoTest{Param: Int32(0)}, &pb.GoTest{}, false}, + {"different set fields", &pb.GoTestField{Label: String("foo")}, &pb.GoTestField{Label: String("bar")}, false}, + {"equal set", &pb.GoTestField{Label: String("foo")}, &pb.GoTestField{Label: String("foo")}, true}, + + {"repeated, one set", &pb.GoTest{F_Int32Repeated: []int32{2, 3}}, &pb.GoTest{}, false}, + {"repeated, different length", &pb.GoTest{F_Int32Repeated: []int32{2, 3}}, &pb.GoTest{F_Int32Repeated: []int32{2}}, false}, + {"repeated, different value", &pb.GoTest{F_Int32Repeated: []int32{2}}, &pb.GoTest{F_Int32Repeated: []int32{3}}, false}, + {"repeated, equal", &pb.GoTest{F_Int32Repeated: []int32{2, 4}}, &pb.GoTest{F_Int32Repeated: []int32{2, 4}}, true}, + {"repeated, nil equal nil", &pb.GoTest{F_Int32Repeated: nil}, &pb.GoTest{F_Int32Repeated: nil}, true}, + {"repeated, nil equal empty", &pb.GoTest{F_Int32Repeated: nil}, &pb.GoTest{F_Int32Repeated: []int32{}}, true}, + {"repeated, empty equal nil", &pb.GoTest{F_Int32Repeated: []int32{}}, &pb.GoTest{F_Int32Repeated: nil}, true}, + + { + "nested, different", + &pb.GoTest{RequiredField: &pb.GoTestField{Label: String("foo")}}, + &pb.GoTest{RequiredField: &pb.GoTestField{Label: String("bar")}}, + false, + }, + { + "nested, equal", + &pb.GoTest{RequiredField: &pb.GoTestField{Label: String("wow")}}, + &pb.GoTest{RequiredField: &pb.GoTestField{Label: String("wow")}}, + true, + }, + + {"bytes", &pb.OtherMessage{Value: []byte("foo")}, &pb.OtherMessage{Value: []byte("foo")}, true}, + {"bytes, empty", &pb.OtherMessage{Value: []byte{}}, &pb.OtherMessage{Value: []byte{}}, true}, + {"bytes, empty vs nil", &pb.OtherMessage{Value: []byte{}}, &pb.OtherMessage{Value: nil}, false}, + { + "repeated bytes", + &pb.MyMessage{RepBytes: [][]byte{[]byte("sham"), []byte("wow")}}, + &pb.MyMessage{RepBytes: [][]byte{[]byte("sham"), []byte("wow")}}, + true, + }, + + {"extension vs. no extension", messageWithoutExtension, messageWithExtension1a, false}, + {"extension vs. same extension", messageWithExtension1a, messageWithExtension1b, true}, + {"extension vs. different extension", messageWithExtension1a, messageWithExtension2, false}, + + {"int32 extension vs. itself", messageWithInt32Extension1, messageWithInt32Extension1, true}, + {"int32 extension vs. a different int32", messageWithInt32Extension1, messageWithInt32Extension2, false}, + + { + "message with group", + &pb.MyMessage{ + Count: Int32(1), + Somegroup: &pb.MyMessage_SomeGroup{ + GroupField: Int32(5), + }, + }, + &pb.MyMessage{ + Count: Int32(1), + Somegroup: &pb.MyMessage_SomeGroup{ + GroupField: Int32(5), + }, + }, + true, + }, + + { + "map same", + &pb.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}}, + &pb.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}}, + true, + }, + { + "map different entry", + &pb.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}}, + &pb.MessageWithMap{NameMapping: map[int32]string{2: "Rob"}}, + false, + }, + { + "map different key only", + &pb.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}}, + &pb.MessageWithMap{NameMapping: map[int32]string{2: "Ken"}}, + false, + }, + { + "map different value only", + &pb.MessageWithMap{NameMapping: map[int32]string{1: "Ken"}}, + &pb.MessageWithMap{NameMapping: map[int32]string{1: "Rob"}}, + false, + }, + { + "oneof same", + &pb.Communique{Union: &pb.Communique_Number{Number: 41}}, + &pb.Communique{Union: &pb.Communique_Number{Number: 41}}, + true, + }, + { + "oneof one nil", + &pb.Communique{Union: &pb.Communique_Number{Number: 41}}, + &pb.Communique{}, + false, + }, + { + "oneof different", + &pb.Communique{Union: &pb.Communique_Number{Number: 41}}, + &pb.Communique{Union: &pb.Communique_Name{Name: "Bobby Tables"}}, + false, + }, +} + +func TestEqual(t *testing.T) { + for _, tc := range EqualTests { + if res := Equal(tc.a, tc.b); res != tc.exp { + t.Errorf("%v: Equal(%v, %v) = %v, want %v", tc.desc, tc.a, tc.b, res, tc.exp) + } + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/extensions.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/extensions.go new file mode 100644 index 0000000000000000000000000000000000000000..9a6374fdbdec488bdbc9e10c6ea83ba11d147460 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/extensions.go @@ -0,0 +1,519 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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 proto + +/* + * Types and routines for supporting protocol buffer extensions. + */ + +import ( + "errors" + "fmt" + "reflect" + "strconv" + "sync" +) + +// ErrMissingExtension is the error returned by GetExtension if the named extension is not in the message. +var ErrMissingExtension = errors.New("proto: missing extension") + +// ExtensionRange represents a range of message extensions for a protocol buffer. +// Used in code generated by the protocol compiler. +type ExtensionRange struct { + Start, End int32 // both inclusive +} + +// extendableProto is an interface implemented by any protocol buffer that may be extended. +type extendableProto interface { + Message + ExtensionRangeArray() []ExtensionRange +} + +type extensionsMap interface { + extendableProto + ExtensionMap() map[int32]Extension +} + +type extensionsBytes interface { + extendableProto + GetExtensions() *[]byte +} + +var extendableProtoType = reflect.TypeOf((*extendableProto)(nil)).Elem() + +// ExtensionDesc represents an extension specification. +// Used in generated code from the protocol compiler. +type ExtensionDesc struct { + ExtendedType Message // nil pointer to the type that is being extended + ExtensionType interface{} // nil pointer to the extension type + Field int32 // field number + Name string // fully-qualified name of extension, for text formatting + Tag string // protobuf tag style +} + +func (ed *ExtensionDesc) repeated() bool { + t := reflect.TypeOf(ed.ExtensionType) + return t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 +} + +// Extension represents an extension in a message. +type Extension struct { + // When an extension is stored in a message using SetExtension + // only desc and value are set. When the message is marshaled + // enc will be set to the encoded form of the message. + // + // When a message is unmarshaled and contains extensions, each + // extension will have only enc set. When such an extension is + // accessed using GetExtension (or GetExtensions) desc and value + // will be set. + desc *ExtensionDesc + value interface{} + enc []byte +} + +// SetRawExtension is for testing only. +func SetRawExtension(base extendableProto, id int32, b []byte) { + if ebase, ok := base.(extensionsMap); ok { + ebase.ExtensionMap()[id] = Extension{enc: b} + } else if ebase, ok := base.(extensionsBytes); ok { + clearExtension(base, id) + ext := ebase.GetExtensions() + *ext = append(*ext, b...) + } else { + panic("unreachable") + } +} + +// isExtensionField returns true iff the given field number is in an extension range. +func isExtensionField(pb extendableProto, field int32) bool { + for _, er := range pb.ExtensionRangeArray() { + if er.Start <= field && field <= er.End { + return true + } + } + return false +} + +// checkExtensionTypes checks that the given extension is valid for pb. +func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error { + // Check the extended type. + if a, b := reflect.TypeOf(pb), reflect.TypeOf(extension.ExtendedType); a != b { + return errors.New("proto: bad extended type; " + b.String() + " does not extend " + a.String()) + } + // Check the range. + if !isExtensionField(pb, extension.Field) { + return errors.New("proto: bad extension number; not in declared ranges") + } + return nil +} + +// extPropKey is sufficient to uniquely identify an extension. +type extPropKey struct { + base reflect.Type + field int32 +} + +var extProp = struct { + sync.RWMutex + m map[extPropKey]*Properties +}{ + m: make(map[extPropKey]*Properties), +} + +func extensionProperties(ed *ExtensionDesc) *Properties { + key := extPropKey{base: reflect.TypeOf(ed.ExtendedType), field: ed.Field} + + extProp.RLock() + if prop, ok := extProp.m[key]; ok { + extProp.RUnlock() + return prop + } + extProp.RUnlock() + + extProp.Lock() + defer extProp.Unlock() + // Check again. + if prop, ok := extProp.m[key]; ok { + return prop + } + + prop := new(Properties) + prop.Init(reflect.TypeOf(ed.ExtensionType), "unknown_name", ed.Tag, nil) + extProp.m[key] = prop + return prop +} + +// encodeExtensionMap encodes any unmarshaled (unencoded) extensions in m. +func encodeExtensionMap(m map[int32]Extension) error { + for k, e := range m { + err := encodeExtension(&e) + if err != nil { + return err + } + m[k] = e + } + return nil +} + +func encodeExtension(e *Extension) error { + if e.value == nil || e.desc == nil { + // Extension is only in its encoded form. + return nil + } + // We don't skip extensions that have an encoded form set, + // because the extension value may have been mutated after + // the last time this function was called. + + et := reflect.TypeOf(e.desc.ExtensionType) + props := extensionProperties(e.desc) + + p := NewBuffer(nil) + // If e.value has type T, the encoder expects a *struct{ X T }. + // Pass a *T with a zero field and hope it all works out. + x := reflect.New(et) + x.Elem().Set(reflect.ValueOf(e.value)) + if err := props.enc(p, props, toStructPointer(x)); err != nil { + return err + } + e.enc = p.buf + return nil +} + +func sizeExtensionMap(m map[int32]Extension) (n int) { + for _, e := range m { + if e.value == nil || e.desc == nil { + // Extension is only in its encoded form. + n += len(e.enc) + continue + } + + // We don't skip extensions that have an encoded form set, + // because the extension value may have been mutated after + // the last time this function was called. + + et := reflect.TypeOf(e.desc.ExtensionType) + props := extensionProperties(e.desc) + + // If e.value has type T, the encoder expects a *struct{ X T }. + // Pass a *T with a zero field and hope it all works out. + x := reflect.New(et) + x.Elem().Set(reflect.ValueOf(e.value)) + n += props.size(props, toStructPointer(x)) + } + return +} + +// HasExtension returns whether the given extension is present in pb. +func HasExtension(pb extendableProto, extension *ExtensionDesc) bool { + // TODO: Check types, field numbers, etc.? + if epb, doki := pb.(extensionsMap); doki { + _, ok := epb.ExtensionMap()[extension.Field] + return ok + } else if epb, doki := pb.(extensionsBytes); doki { + ext := epb.GetExtensions() + buf := *ext + o := 0 + for o < len(buf) { + tag, n := DecodeVarint(buf[o:]) + fieldNum := int32(tag >> 3) + if int32(fieldNum) == extension.Field { + return true + } + wireType := int(tag & 0x7) + o += n + l, err := size(buf[o:], wireType) + if err != nil { + return false + } + o += l + } + return false + } + panic("unreachable") +} + +func deleteExtension(pb extensionsBytes, theFieldNum int32, offset int) int { + ext := pb.GetExtensions() + for offset < len(*ext) { + tag, n1 := DecodeVarint((*ext)[offset:]) + fieldNum := int32(tag >> 3) + wireType := int(tag & 0x7) + n2, err := size((*ext)[offset+n1:], wireType) + if err != nil { + panic(err) + } + newOffset := offset + n1 + n2 + if fieldNum == theFieldNum { + *ext = append((*ext)[:offset], (*ext)[newOffset:]...) + return offset + } + offset = newOffset + } + return -1 +} + +func clearExtension(pb extendableProto, fieldNum int32) { + if epb, doki := pb.(extensionsMap); doki { + delete(epb.ExtensionMap(), fieldNum) + } else if epb, doki := pb.(extensionsBytes); doki { + offset := 0 + for offset != -1 { + offset = deleteExtension(epb, fieldNum, offset) + } + } else { + panic("unreachable") + } +} + +// ClearExtension removes the given extension from pb. +func ClearExtension(pb extendableProto, extension *ExtensionDesc) { + // TODO: Check types, field numbers, etc.? + clearExtension(pb, extension.Field) +} + +// GetExtension parses and returns the given extension of pb. +// If the extension is not present it returns ErrMissingExtension. +func GetExtension(pb extendableProto, extension *ExtensionDesc) (interface{}, error) { + if err := checkExtensionTypes(pb, extension); err != nil { + return nil, err + } + + if epb, doki := pb.(extensionsMap); doki { + emap := epb.ExtensionMap() + e, ok := emap[extension.Field] + if !ok { + // defaultExtensionValue returns the default value or + // ErrMissingExtension if there is no default. + return defaultExtensionValue(extension) + } + if e.value != nil { + // Already decoded. Check the descriptor, though. + if e.desc != extension { + // This shouldn't happen. If it does, it means that + // GetExtension was called twice with two different + // descriptors with the same field number. + return nil, errors.New("proto: descriptor conflict") + } + return e.value, nil + } + + v, err := decodeExtension(e.enc, extension) + if err != nil { + return nil, err + } + + // Remember the decoded version and drop the encoded version. + // That way it is safe to mutate what we return. + e.value = v + e.desc = extension + e.enc = nil + emap[extension.Field] = e + return e.value, nil + } else if epb, doki := pb.(extensionsBytes); doki { + ext := epb.GetExtensions() + o := 0 + for o < len(*ext) { + tag, n := DecodeVarint((*ext)[o:]) + fieldNum := int32(tag >> 3) + wireType := int(tag & 0x7) + l, err := size((*ext)[o+n:], wireType) + if err != nil { + return nil, err + } + if int32(fieldNum) == extension.Field { + v, err := decodeExtension((*ext)[o:o+n+l], extension) + if err != nil { + return nil, err + } + return v, nil + } + o += n + l + } + return defaultExtensionValue(extension) + } + panic("unreachable") +} + +// defaultExtensionValue returns the default value for extension. +// If no default for an extension is defined ErrMissingExtension is returned. +func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) { + t := reflect.TypeOf(extension.ExtensionType) + props := extensionProperties(extension) + + sf, _, err := fieldDefault(t, props) + if err != nil { + return nil, err + } + + if sf == nil || sf.value == nil { + // There is no default value. + return nil, ErrMissingExtension + } + + if t.Kind() != reflect.Ptr { + // We do not need to return a Ptr, we can directly return sf.value. + return sf.value, nil + } + + // We need to return an interface{} that is a pointer to sf.value. + value := reflect.New(t).Elem() + value.Set(reflect.New(value.Type().Elem())) + if sf.kind == reflect.Int32 { + // We may have an int32 or an enum, but the underlying data is int32. + // Since we can't set an int32 into a non int32 reflect.value directly + // set it as a int32. + value.Elem().SetInt(int64(sf.value.(int32))) + } else { + value.Elem().Set(reflect.ValueOf(sf.value)) + } + return value.Interface(), nil +} + +// decodeExtension decodes an extension encoded in b. +func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) { + o := NewBuffer(b) + + t := reflect.TypeOf(extension.ExtensionType) + rep := extension.repeated() + + props := extensionProperties(extension) + + // t is a pointer to a struct, pointer to basic type or a slice. + // Allocate a "field" to store the pointer/slice itself; the + // pointer/slice will be stored here. We pass + // the address of this field to props.dec. + // This passes a zero field and a *t and lets props.dec + // interpret it as a *struct{ x t }. + value := reflect.New(t).Elem() + + for { + // Discard wire type and field number varint. It isn't needed. + if _, err := o.DecodeVarint(); err != nil { + return nil, err + } + + if err := props.dec(o, props, toStructPointer(value.Addr())); err != nil { + return nil, err + } + + if !rep || o.index >= len(o.buf) { + break + } + } + return value.Interface(), nil +} + +// GetExtensions returns a slice of the extensions present in pb that are also listed in es. +// The returned slice has the same length as es; missing extensions will appear as nil elements. +func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) { + epb, ok := pb.(extendableProto) + if !ok { + err = errors.New("proto: not an extendable proto") + return + } + extensions = make([]interface{}, len(es)) + for i, e := range es { + extensions[i], err = GetExtension(epb, e) + if err == ErrMissingExtension { + err = nil + } + if err != nil { + return + } + } + return +} + +// SetExtension sets the specified extension of pb to the specified value. +func SetExtension(pb extendableProto, extension *ExtensionDesc, value interface{}) error { + if err := checkExtensionTypes(pb, extension); err != nil { + return err + } + typ := reflect.TypeOf(extension.ExtensionType) + if typ != reflect.TypeOf(value) { + return errors.New("proto: bad extension value type") + } + // nil extension values need to be caught early, because the + // encoder can't distinguish an ErrNil due to a nil extension + // from an ErrNil due to a missing field. Extensions are + // always optional, so the encoder would just swallow the error + // and drop all the extensions from the encoded message. + if reflect.ValueOf(value).IsNil() { + return fmt.Errorf("proto: SetExtension called with nil value of type %T", value) + } + return setExtension(pb, extension, value) +} + +func setExtension(pb extendableProto, extension *ExtensionDesc, value interface{}) error { + if epb, doki := pb.(extensionsMap); doki { + epb.ExtensionMap()[extension.Field] = Extension{desc: extension, value: value} + } else if epb, doki := pb.(extensionsBytes); doki { + ClearExtension(pb, extension) + ext := epb.GetExtensions() + et := reflect.TypeOf(extension.ExtensionType) + props := extensionProperties(extension) + p := NewBuffer(nil) + x := reflect.New(et) + x.Elem().Set(reflect.ValueOf(value)) + if err := props.enc(p, props, toStructPointer(x)); err != nil { + return err + } + *ext = append(*ext, p.buf...) + } + return nil +} + +// A global registry of extensions. +// The generated code will register the generated descriptors by calling RegisterExtension. + +var extensionMaps = make(map[reflect.Type]map[int32]*ExtensionDesc) + +// RegisterExtension is called from the generated code. +func RegisterExtension(desc *ExtensionDesc) { + st := reflect.TypeOf(desc.ExtendedType).Elem() + m := extensionMaps[st] + if m == nil { + m = make(map[int32]*ExtensionDesc) + extensionMaps[st] = m + } + if _, ok := m[desc.Field]; ok { + panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field))) + } + m[desc.Field] = desc +} + +// RegisteredExtensions returns a map of the registered extensions of a +// protocol buffer struct, indexed by the extension number. +// The argument pb should be a nil pointer to the struct type. +func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc { + return extensionMaps[reflect.TypeOf(pb).Elem()] +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/extensions_gogo.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/extensions_gogo.go new file mode 100644 index 0000000000000000000000000000000000000000..bd55fb68b61efe865979c32e6d5ebf0abe10b68b --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/extensions_gogo.go @@ -0,0 +1,221 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 proto + +import ( + "bytes" + "errors" + "fmt" + "reflect" + "sort" + "strings" +) + +func GetBoolExtension(pb extendableProto, extension *ExtensionDesc, ifnotset bool) bool { + if reflect.ValueOf(pb).IsNil() { + return ifnotset + } + value, err := GetExtension(pb, extension) + if err != nil { + return ifnotset + } + if value == nil { + return ifnotset + } + if value.(*bool) == nil { + return ifnotset + } + return *(value.(*bool)) +} + +func (this *Extension) Equal(that *Extension) bool { + return bytes.Equal(this.enc, that.enc) +} + +func SizeOfExtensionMap(m map[int32]Extension) (n int) { + return sizeExtensionMap(m) +} + +type sortableMapElem struct { + field int32 + ext Extension +} + +func newSortableExtensionsFromMap(m map[int32]Extension) sortableExtensions { + s := make(sortableExtensions, 0, len(m)) + for k, v := range m { + s = append(s, &sortableMapElem{field: k, ext: v}) + } + return s +} + +type sortableExtensions []*sortableMapElem + +func (this sortableExtensions) Len() int { return len(this) } + +func (this sortableExtensions) Swap(i, j int) { this[i], this[j] = this[j], this[i] } + +func (this sortableExtensions) Less(i, j int) bool { return this[i].field < this[j].field } + +func (this sortableExtensions) String() string { + sort.Sort(this) + ss := make([]string, len(this)) + for i := range this { + ss[i] = fmt.Sprintf("%d: %v", this[i].field, this[i].ext) + } + return "map[" + strings.Join(ss, ",") + "]" +} + +func StringFromExtensionsMap(m map[int32]Extension) string { + return newSortableExtensionsFromMap(m).String() +} + +func StringFromExtensionsBytes(ext []byte) string { + m, err := BytesToExtensionsMap(ext) + if err != nil { + panic(err) + } + return StringFromExtensionsMap(m) +} + +func EncodeExtensionMap(m map[int32]Extension, data []byte) (n int, err error) { + if err := encodeExtensionMap(m); err != nil { + return 0, err + } + keys := make([]int, 0, len(m)) + for k := range m { + keys = append(keys, int(k)) + } + sort.Ints(keys) + for _, k := range keys { + n += copy(data[n:], m[int32(k)].enc) + } + return n, nil +} + +func GetRawExtension(m map[int32]Extension, id int32) ([]byte, error) { + if m[id].value == nil || m[id].desc == nil { + return m[id].enc, nil + } + if err := encodeExtensionMap(m); err != nil { + return nil, err + } + return m[id].enc, nil +} + +func size(buf []byte, wire int) (int, error) { + switch wire { + case WireVarint: + _, n := DecodeVarint(buf) + return n, nil + case WireFixed64: + return 8, nil + case WireBytes: + v, n := DecodeVarint(buf) + return int(v) + n, nil + case WireFixed32: + return 4, nil + case WireStartGroup: + offset := 0 + for { + u, n := DecodeVarint(buf[offset:]) + fwire := int(u & 0x7) + offset += n + if fwire == WireEndGroup { + return offset, nil + } + s, err := size(buf[offset:], wire) + if err != nil { + return 0, err + } + offset += s + } + } + return 0, fmt.Errorf("proto: can't get size for unknown wire type %d", wire) +} + +func BytesToExtensionsMap(buf []byte) (map[int32]Extension, error) { + m := make(map[int32]Extension) + i := 0 + for i < len(buf) { + tag, n := DecodeVarint(buf[i:]) + if n <= 0 { + return nil, fmt.Errorf("unable to decode varint") + } + fieldNum := int32(tag >> 3) + wireType := int(tag & 0x7) + l, err := size(buf[i+n:], wireType) + if err != nil { + return nil, err + } + end := i + int(l) + n + m[int32(fieldNum)] = Extension{enc: buf[i:end]} + i = end + } + return m, nil +} + +func NewExtension(e []byte) Extension { + ee := Extension{enc: make([]byte, len(e))} + copy(ee.enc, e) + return ee +} + +func (this Extension) GoString() string { + if this.enc == nil { + if err := encodeExtension(&this); err != nil { + panic(err) + } + } + return fmt.Sprintf("proto.NewExtension(%#v)", this.enc) +} + +func SetUnsafeExtension(pb extendableProto, fieldNum int32, value interface{}) error { + typ := reflect.TypeOf(pb).Elem() + ext, ok := extensionMaps[typ] + if !ok { + return fmt.Errorf("proto: bad extended type; %s is not extendable", typ.String()) + } + desc, ok := ext[fieldNum] + if !ok { + return errors.New("proto: bad extension number; not in declared ranges") + } + return setExtension(pb, desc, value) +} + +func GetUnsafeExtension(pb extendableProto, fieldNum int32) (interface{}, error) { + typ := reflect.TypeOf(pb).Elem() + ext, ok := extensionMaps[typ] + if !ok { + return nil, fmt.Errorf("proto: bad extended type; %s is not extendable", typ.String()) + } + desc, ok := ext[fieldNum] + if !ok { + return nil, fmt.Errorf("unregistered field number %d", fieldNum) + } + return GetExtension(pb, desc) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/extensions_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/extensions_test.go new file mode 100644 index 0000000000000000000000000000000000000000..5f8fa1d4e382c23ffe6923b6097bc3ced55a91fd --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/extensions_test.go @@ -0,0 +1,292 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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 proto_test + +import ( + "fmt" + "reflect" + "testing" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + pb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata" +) + +func TestGetExtensionsWithMissingExtensions(t *testing.T) { + msg := &pb.MyMessage{} + ext1 := &pb.Ext{} + if err := proto.SetExtension(msg, pb.E_Ext_More, ext1); err != nil { + t.Fatalf("Could not set ext1: %s", ext1) + } + exts, err := proto.GetExtensions(msg, []*proto.ExtensionDesc{ + pb.E_Ext_More, + pb.E_Ext_Text, + }) + if err != nil { + t.Fatalf("GetExtensions() failed: %s", err) + } + if exts[0] != ext1 { + t.Errorf("ext1 not in returned extensions: %T %v", exts[0], exts[0]) + } + if exts[1] != nil { + t.Errorf("ext2 in returned extensions: %T %v", exts[1], exts[1]) + } +} + +func TestGetExtensionStability(t *testing.T) { + check := func(m *pb.MyMessage) bool { + ext1, err := proto.GetExtension(m, pb.E_Ext_More) + if err != nil { + t.Fatalf("GetExtension() failed: %s", err) + } + ext2, err := proto.GetExtension(m, pb.E_Ext_More) + if err != nil { + t.Fatalf("GetExtension() failed: %s", err) + } + return ext1 == ext2 + } + msg := &pb.MyMessage{Count: proto.Int32(4)} + ext0 := &pb.Ext{} + if err := proto.SetExtension(msg, pb.E_Ext_More, ext0); err != nil { + t.Fatalf("Could not set ext1: %s", ext0) + } + if !check(msg) { + t.Errorf("GetExtension() not stable before marshaling") + } + bb, err := proto.Marshal(msg) + if err != nil { + t.Fatalf("Marshal() failed: %s", err) + } + msg1 := &pb.MyMessage{} + err = proto.Unmarshal(bb, msg1) + if err != nil { + t.Fatalf("Unmarshal() failed: %s", err) + } + if !check(msg1) { + t.Errorf("GetExtension() not stable after unmarshaling") + } +} + +func TestGetExtensionDefaults(t *testing.T) { + var setFloat64 float64 = 1 + var setFloat32 float32 = 2 + var setInt32 int32 = 3 + var setInt64 int64 = 4 + var setUint32 uint32 = 5 + var setUint64 uint64 = 6 + var setBool = true + var setBool2 = false + var setString = "Goodnight string" + var setBytes = []byte("Goodnight bytes") + var setEnum = pb.DefaultsMessage_TWO + + type testcase struct { + ext *proto.ExtensionDesc // Extension we are testing. + want interface{} // Expected value of extension, or nil (meaning that GetExtension will fail). + def interface{} // Expected value of extension after ClearExtension(). + } + tests := []testcase{ + {pb.E_NoDefaultDouble, setFloat64, nil}, + {pb.E_NoDefaultFloat, setFloat32, nil}, + {pb.E_NoDefaultInt32, setInt32, nil}, + {pb.E_NoDefaultInt64, setInt64, nil}, + {pb.E_NoDefaultUint32, setUint32, nil}, + {pb.E_NoDefaultUint64, setUint64, nil}, + {pb.E_NoDefaultSint32, setInt32, nil}, + {pb.E_NoDefaultSint64, setInt64, nil}, + {pb.E_NoDefaultFixed32, setUint32, nil}, + {pb.E_NoDefaultFixed64, setUint64, nil}, + {pb.E_NoDefaultSfixed32, setInt32, nil}, + {pb.E_NoDefaultSfixed64, setInt64, nil}, + {pb.E_NoDefaultBool, setBool, nil}, + {pb.E_NoDefaultBool, setBool2, nil}, + {pb.E_NoDefaultString, setString, nil}, + {pb.E_NoDefaultBytes, setBytes, nil}, + {pb.E_NoDefaultEnum, setEnum, nil}, + {pb.E_DefaultDouble, setFloat64, float64(3.1415)}, + {pb.E_DefaultFloat, setFloat32, float32(3.14)}, + {pb.E_DefaultInt32, setInt32, int32(42)}, + {pb.E_DefaultInt64, setInt64, int64(43)}, + {pb.E_DefaultUint32, setUint32, uint32(44)}, + {pb.E_DefaultUint64, setUint64, uint64(45)}, + {pb.E_DefaultSint32, setInt32, int32(46)}, + {pb.E_DefaultSint64, setInt64, int64(47)}, + {pb.E_DefaultFixed32, setUint32, uint32(48)}, + {pb.E_DefaultFixed64, setUint64, uint64(49)}, + {pb.E_DefaultSfixed32, setInt32, int32(50)}, + {pb.E_DefaultSfixed64, setInt64, int64(51)}, + {pb.E_DefaultBool, setBool, true}, + {pb.E_DefaultBool, setBool2, true}, + {pb.E_DefaultString, setString, "Hello, string"}, + {pb.E_DefaultBytes, setBytes, []byte("Hello, bytes")}, + {pb.E_DefaultEnum, setEnum, pb.DefaultsMessage_ONE}, + } + + checkVal := func(test testcase, msg *pb.DefaultsMessage, valWant interface{}) error { + val, err := proto.GetExtension(msg, test.ext) + if err != nil { + if valWant != nil { + return fmt.Errorf("GetExtension(): %s", err) + } + if want := proto.ErrMissingExtension; err != want { + return fmt.Errorf("Unexpected error: got %v, want %v", err, want) + } + return nil + } + + // All proto2 extension values are either a pointer to a value or a slice of values. + ty := reflect.TypeOf(val) + tyWant := reflect.TypeOf(test.ext.ExtensionType) + if got, want := ty, tyWant; got != want { + return fmt.Errorf("unexpected reflect.TypeOf(): got %v want %v", got, want) + } + tye := ty.Elem() + tyeWant := tyWant.Elem() + if got, want := tye, tyeWant; got != want { + return fmt.Errorf("unexpected reflect.TypeOf().Elem(): got %v want %v", got, want) + } + + // Check the name of the type of the value. + // If it is an enum it will be type int32 with the name of the enum. + if got, want := tye.Name(), tye.Name(); got != want { + return fmt.Errorf("unexpected reflect.TypeOf().Elem().Name(): got %v want %v", got, want) + } + + // Check that value is what we expect. + // If we have a pointer in val, get the value it points to. + valExp := val + if ty.Kind() == reflect.Ptr { + valExp = reflect.ValueOf(val).Elem().Interface() + } + if got, want := valExp, valWant; !reflect.DeepEqual(got, want) { + return fmt.Errorf("unexpected reflect.DeepEqual(): got %v want %v", got, want) + } + + return nil + } + + setTo := func(test testcase) interface{} { + setTo := reflect.ValueOf(test.want) + if typ := reflect.TypeOf(test.ext.ExtensionType); typ.Kind() == reflect.Ptr { + setTo = reflect.New(typ).Elem() + setTo.Set(reflect.New(setTo.Type().Elem())) + setTo.Elem().Set(reflect.ValueOf(test.want)) + } + return setTo.Interface() + } + + for _, test := range tests { + msg := &pb.DefaultsMessage{} + name := test.ext.Name + + // Check the initial value. + if err := checkVal(test, msg, test.def); err != nil { + t.Errorf("%s: %v", name, err) + } + + // Set the per-type value and check value. + name = fmt.Sprintf("%s (set to %T %v)", name, test.want, test.want) + if err := proto.SetExtension(msg, test.ext, setTo(test)); err != nil { + t.Errorf("%s: SetExtension(): %v", name, err) + continue + } + if err := checkVal(test, msg, test.want); err != nil { + t.Errorf("%s: %v", name, err) + continue + } + + // Set and check the value. + name += " (cleared)" + proto.ClearExtension(msg, test.ext) + if err := checkVal(test, msg, test.def); err != nil { + t.Errorf("%s: %v", name, err) + } + } +} + +func TestExtensionsRoundTrip(t *testing.T) { + msg := &pb.MyMessage{} + ext1 := &pb.Ext{ + Data: proto.String("hi"), + } + ext2 := &pb.Ext{ + Data: proto.String("there"), + } + exists := proto.HasExtension(msg, pb.E_Ext_More) + if exists { + t.Error("Extension More present unexpectedly") + } + if err := proto.SetExtension(msg, pb.E_Ext_More, ext1); err != nil { + t.Error(err) + } + if err := proto.SetExtension(msg, pb.E_Ext_More, ext2); err != nil { + t.Error(err) + } + e, err := proto.GetExtension(msg, pb.E_Ext_More) + if err != nil { + t.Error(err) + } + x, ok := e.(*pb.Ext) + if !ok { + t.Errorf("e has type %T, expected testdata.Ext", e) + } else if *x.Data != "there" { + t.Errorf("SetExtension failed to overwrite, got %+v, not 'there'", x) + } + proto.ClearExtension(msg, pb.E_Ext_More) + if _, err = proto.GetExtension(msg, pb.E_Ext_More); err != proto.ErrMissingExtension { + t.Errorf("got %v, expected ErrMissingExtension", e) + } + if _, err := proto.GetExtension(msg, pb.E_X215); err == nil { + t.Error("expected bad extension error, got nil") + } + if err := proto.SetExtension(msg, pb.E_X215, 12); err == nil { + t.Error("expected extension err") + } + if err := proto.SetExtension(msg, pb.E_Ext_More, 12); err == nil { + t.Error("expected some sort of type mismatch error, got nil") + } +} + +func TestNilExtension(t *testing.T) { + msg := &pb.MyMessage{ + Count: proto.Int32(1), + } + if err := proto.SetExtension(msg, pb.E_Ext_Text, proto.String("hello")); err != nil { + t.Fatal(err) + } + if err := proto.SetExtension(msg, pb.E_Ext_More, (*pb.Ext)(nil)); err == nil { + t.Error("expected SetExtension to fail due to a nil extension") + } else if want := "proto: SetExtension called with nil value of type *testdata.Ext"; err.Error() != want { + t.Errorf("expected error %v, got %v", want, err) + } + // Note: if the behavior of Marshal is ever changed to ignore nil extensions, update + // this test to verify that E_Ext_Text is properly propagated through marshal->unmarshal. +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/lib.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/lib.go new file mode 100644 index 0000000000000000000000000000000000000000..b964734c7728fc90311a59c3f8393d02679c297d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/lib.go @@ -0,0 +1,883 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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 proto converts data structures to and from the wire format of +protocol buffers. It works in concert with the Go source code generated +for .proto files by the protocol compiler. + +A summary of the properties of the protocol buffer interface +for a protocol buffer variable v: + + - Names are turned from camel_case to CamelCase for export. + - There are no methods on v to set fields; just treat + them as structure fields. + - There are getters that return a field's value if set, + and return the field's default value if unset. + The getters work even if the receiver is a nil message. + - The zero value for a struct is its correct initialization state. + All desired fields must be set before marshaling. + - A Reset() method will restore a protobuf struct to its zero state. + - Non-repeated fields are pointers to the values; nil means unset. + That is, optional or required field int32 f becomes F *int32. + - Repeated fields are slices. + - Helper functions are available to aid the setting of fields. + msg.Foo = proto.String("hello") // set field + - Constants are defined to hold the default values of all fields that + have them. They have the form Default_StructName_FieldName. + Because the getter methods handle defaulted values, + direct use of these constants should be rare. + - Enums are given type names and maps from names to values. + Enum values are prefixed by the enclosing message's name, or by the + enum's type name if it is a top-level enum. Enum types have a String + method, and a Enum method to assist in message construction. + - Nested messages, groups and enums have type names prefixed with the name of + the surrounding message type. + - Extensions are given descriptor names that start with E_, + followed by an underscore-delimited list of the nested messages + that contain it (if any) followed by the CamelCased name of the + extension field itself. HasExtension, ClearExtension, GetExtension + and SetExtension are functions for manipulating extensions. + - Oneof field sets are given a single field in their message, + with distinguished wrapper types for each possible field value. + - Marshal and Unmarshal are functions to encode and decode the wire format. + +The simplest way to describe this is to see an example. +Given file test.proto, containing + + package example; + + enum FOO { X = 17; } + + message Test { + required string label = 1; + optional int32 type = 2 [default=77]; + repeated int64 reps = 3; + optional group OptionalGroup = 4 { + required string RequiredField = 5; + } + oneof union { + int32 number = 6; + string name = 7; + } + } + +The resulting file, test.pb.go, is: + + package example + + import proto "github.com/gogo/protobuf/proto" + import math "math" + + type FOO int32 + const ( + FOO_X FOO = 17 + ) + var FOO_name = map[int32]string{ + 17: "X", + } + var FOO_value = map[string]int32{ + "X": 17, + } + + func (x FOO) Enum() *FOO { + p := new(FOO) + *p = x + return p + } + func (x FOO) String() string { + return proto.EnumName(FOO_name, int32(x)) + } + func (x *FOO) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FOO_value, data) + if err != nil { + return err + } + *x = FOO(value) + return nil + } + + type Test struct { + Label *string `protobuf:"bytes,1,req,name=label" json:"label,omitempty"` + Type *int32 `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"` + Reps []int64 `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"` + Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"` + // Types that are valid to be assigned to Union: + // *Test_Number + // *Test_Name + Union isTest_Union `protobuf_oneof:"union"` + XXX_unrecognized []byte `json:"-"` + } + func (m *Test) Reset() { *m = Test{} } + func (m *Test) String() string { return proto.CompactTextString(m) } + func (*Test) ProtoMessage() {} + + type isTest_Union interface { + isTest_Union() + } + + type Test_Number struct { + Number int32 `protobuf:"varint,6,opt,name=number"` + } + type Test_Name struct { + Name string `protobuf:"bytes,7,opt,name=name"` + } + + func (*Test_Number) isTest_Union() {} + func (*Test_Name) isTest_Union() {} + + func (m *Test) GetUnion() isTest_Union { + if m != nil { + return m.Union + } + return nil + } + const Default_Test_Type int32 = 77 + + func (m *Test) GetLabel() string { + if m != nil && m.Label != nil { + return *m.Label + } + return "" + } + + func (m *Test) GetType() int32 { + if m != nil && m.Type != nil { + return *m.Type + } + return Default_Test_Type + } + + func (m *Test) GetOptionalgroup() *Test_OptionalGroup { + if m != nil { + return m.Optionalgroup + } + return nil + } + + type Test_OptionalGroup struct { + RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"` + } + func (m *Test_OptionalGroup) Reset() { *m = Test_OptionalGroup{} } + func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) } + + func (m *Test_OptionalGroup) GetRequiredField() string { + if m != nil && m.RequiredField != nil { + return *m.RequiredField + } + return "" + } + + func (m *Test) GetNumber() int32 { + if x, ok := m.GetUnion().(*Test_Number); ok { + return x.Number + } + return 0 + } + + func (m *Test) GetName() string { + if x, ok := m.GetUnion().(*Test_Name); ok { + return x.Name + } + return "" + } + + func init() { + proto.RegisterEnum("example.FOO", FOO_name, FOO_value) + } + +To create and play with a Test object: + +package main + + import ( + "log" + + "github.com/gogo/protobuf/proto" + pb "./example.pb" + ) + + func main() { + test := &pb.Test{ + Label: proto.String("hello"), + Type: proto.Int32(17), + Optionalgroup: &pb.Test_OptionalGroup{ + RequiredField: proto.String("good bye"), + }, + Union: &pb.Test_Name{"fred"}, + } + data, err := proto.Marshal(test) + if err != nil { + log.Fatal("marshaling error: ", err) + } + newTest := &pb.Test{} + err = proto.Unmarshal(data, newTest) + if err != nil { + log.Fatal("unmarshaling error: ", err) + } + // Now test and newTest contain the same data. + if test.GetLabel() != newTest.GetLabel() { + log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel()) + } + // Use a type switch to determine which oneof was set. + switch u := test.Union.(type) { + case *pb.Test_Number: // u.Number contains the number. + case *pb.Test_Name: // u.Name contains the string. + } + // etc. + } +*/ +package proto + +import ( + "encoding/json" + "fmt" + "log" + "reflect" + "sort" + "strconv" + "sync" +) + +// Message is implemented by generated protocol buffer messages. +type Message interface { + Reset() + String() string + ProtoMessage() +} + +// Stats records allocation details about the protocol buffer encoders +// and decoders. Useful for tuning the library itself. +type Stats struct { + Emalloc uint64 // mallocs in encode + Dmalloc uint64 // mallocs in decode + Encode uint64 // number of encodes + Decode uint64 // number of decodes + Chit uint64 // number of cache hits + Cmiss uint64 // number of cache misses + Size uint64 // number of sizes +} + +// Set to true to enable stats collection. +const collectStats = false + +var stats Stats + +// GetStats returns a copy of the global Stats structure. +func GetStats() Stats { return stats } + +// A Buffer is a buffer manager for marshaling and unmarshaling +// protocol buffers. It may be reused between invocations to +// reduce memory usage. It is not necessary to use a Buffer; +// the global functions Marshal and Unmarshal create a +// temporary Buffer and are fine for most applications. +type Buffer struct { + buf []byte // encode/decode byte stream + index int // write point + + // pools of basic types to amortize allocation. + bools []bool + uint32s []uint32 + uint64s []uint64 + + // extra pools, only used with pointer_reflect.go + int32s []int32 + int64s []int64 + float32s []float32 + float64s []float64 +} + +// NewBuffer allocates a new Buffer and initializes its internal data to +// the contents of the argument slice. +func NewBuffer(e []byte) *Buffer { + return &Buffer{buf: e} +} + +// Reset resets the Buffer, ready for marshaling a new protocol buffer. +func (p *Buffer) Reset() { + p.buf = p.buf[0:0] // for reading/writing + p.index = 0 // for reading +} + +// SetBuf replaces the internal buffer with the slice, +// ready for unmarshaling the contents of the slice. +func (p *Buffer) SetBuf(s []byte) { + p.buf = s + p.index = 0 +} + +// Bytes returns the contents of the Buffer. +func (p *Buffer) Bytes() []byte { return p.buf } + +/* + * Helper routines for simplifying the creation of optional fields of basic type. + */ + +// Bool is a helper routine that allocates a new bool value +// to store v and returns a pointer to it. +func Bool(v bool) *bool { + return &v +} + +// Int32 is a helper routine that allocates a new int32 value +// to store v and returns a pointer to it. +func Int32(v int32) *int32 { + return &v +} + +// Int is a helper routine that allocates a new int32 value +// to store v and returns a pointer to it, but unlike Int32 +// its argument value is an int. +func Int(v int) *int32 { + p := new(int32) + *p = int32(v) + return p +} + +// Int64 is a helper routine that allocates a new int64 value +// to store v and returns a pointer to it. +func Int64(v int64) *int64 { + return &v +} + +// Float32 is a helper routine that allocates a new float32 value +// to store v and returns a pointer to it. +func Float32(v float32) *float32 { + return &v +} + +// Float64 is a helper routine that allocates a new float64 value +// to store v and returns a pointer to it. +func Float64(v float64) *float64 { + return &v +} + +// Uint32 is a helper routine that allocates a new uint32 value +// to store v and returns a pointer to it. +func Uint32(v uint32) *uint32 { + return &v +} + +// Uint64 is a helper routine that allocates a new uint64 value +// to store v and returns a pointer to it. +func Uint64(v uint64) *uint64 { + return &v +} + +// String is a helper routine that allocates a new string value +// to store v and returns a pointer to it. +func String(v string) *string { + return &v +} + +// EnumName is a helper function to simplify printing protocol buffer enums +// by name. Given an enum map and a value, it returns a useful string. +func EnumName(m map[int32]string, v int32) string { + s, ok := m[v] + if ok { + return s + } + return strconv.Itoa(int(v)) +} + +// UnmarshalJSONEnum is a helper function to simplify recovering enum int values +// from their JSON-encoded representation. Given a map from the enum's symbolic +// names to its int values, and a byte buffer containing the JSON-encoded +// value, it returns an int32 that can be cast to the enum type by the caller. +// +// The function can deal with both JSON representations, numeric and symbolic. +func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) { + if data[0] == '"' { + // New style: enums are strings. + var repr string + if err := json.Unmarshal(data, &repr); err != nil { + return -1, err + } + val, ok := m[repr] + if !ok { + return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr) + } + return val, nil + } + // Old style: enums are ints. + var val int32 + if err := json.Unmarshal(data, &val); err != nil { + return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName) + } + return val, nil +} + +// DebugPrint dumps the encoded data in b in a debugging format with a header +// including the string s. Used in testing but made available for general debugging. +func (p *Buffer) DebugPrint(s string, b []byte) { + var u uint64 + + obuf := p.buf + index := p.index + p.buf = b + p.index = 0 + depth := 0 + + fmt.Printf("\n--- %s ---\n", s) + +out: + for { + for i := 0; i < depth; i++ { + fmt.Print(" ") + } + + index := p.index + if index == len(p.buf) { + break + } + + op, err := p.DecodeVarint() + if err != nil { + fmt.Printf("%3d: fetching op err %v\n", index, err) + break out + } + tag := op >> 3 + wire := op & 7 + + switch wire { + default: + fmt.Printf("%3d: t=%3d unknown wire=%d\n", + index, tag, wire) + break out + + case WireBytes: + var r []byte + + r, err = p.DecodeRawBytes(false) + if err != nil { + break out + } + fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r)) + if len(r) <= 6 { + for i := 0; i < len(r); i++ { + fmt.Printf(" %.2x", r[i]) + } + } else { + for i := 0; i < 3; i++ { + fmt.Printf(" %.2x", r[i]) + } + fmt.Printf(" ..") + for i := len(r) - 3; i < len(r); i++ { + fmt.Printf(" %.2x", r[i]) + } + } + fmt.Printf("\n") + + case WireFixed32: + u, err = p.DecodeFixed32() + if err != nil { + fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err) + break out + } + fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u) + + case WireFixed64: + u, err = p.DecodeFixed64() + if err != nil { + fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err) + break out + } + fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u) + + case WireVarint: + u, err = p.DecodeVarint() + if err != nil { + fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err) + break out + } + fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u) + + case WireStartGroup: + fmt.Printf("%3d: t=%3d start\n", index, tag) + depth++ + + case WireEndGroup: + depth-- + fmt.Printf("%3d: t=%3d end\n", index, tag) + } + } + + if depth != 0 { + fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth) + } + fmt.Printf("\n") + + p.buf = obuf + p.index = index +} + +// SetDefaults sets unset protocol buffer fields to their default values. +// It only modifies fields that are both unset and have defined defaults. +// It recursively sets default values in any non-nil sub-messages. +func SetDefaults(pb Message) { + setDefaults(reflect.ValueOf(pb), true, false) +} + +// v is a pointer to a struct. +func setDefaults(v reflect.Value, recur, zeros bool) { + v = v.Elem() + + defaultMu.RLock() + dm, ok := defaults[v.Type()] + defaultMu.RUnlock() + if !ok { + dm = buildDefaultMessage(v.Type()) + defaultMu.Lock() + defaults[v.Type()] = dm + defaultMu.Unlock() + } + + for _, sf := range dm.scalars { + f := v.Field(sf.index) + if !f.IsNil() { + // field already set + continue + } + dv := sf.value + if dv == nil && !zeros { + // no explicit default, and don't want to set zeros + continue + } + fptr := f.Addr().Interface() // **T + // TODO: Consider batching the allocations we do here. + switch sf.kind { + case reflect.Bool: + b := new(bool) + if dv != nil { + *b = dv.(bool) + } + *(fptr.(**bool)) = b + case reflect.Float32: + f := new(float32) + if dv != nil { + *f = dv.(float32) + } + *(fptr.(**float32)) = f + case reflect.Float64: + f := new(float64) + if dv != nil { + *f = dv.(float64) + } + *(fptr.(**float64)) = f + case reflect.Int32: + // might be an enum + if ft := f.Type(); ft != int32PtrType { + // enum + f.Set(reflect.New(ft.Elem())) + if dv != nil { + f.Elem().SetInt(int64(dv.(int32))) + } + } else { + // int32 field + i := new(int32) + if dv != nil { + *i = dv.(int32) + } + *(fptr.(**int32)) = i + } + case reflect.Int64: + i := new(int64) + if dv != nil { + *i = dv.(int64) + } + *(fptr.(**int64)) = i + case reflect.String: + s := new(string) + if dv != nil { + *s = dv.(string) + } + *(fptr.(**string)) = s + case reflect.Uint8: + // exceptional case: []byte + var b []byte + if dv != nil { + db := dv.([]byte) + b = make([]byte, len(db)) + copy(b, db) + } else { + b = []byte{} + } + *(fptr.(*[]byte)) = b + case reflect.Uint32: + u := new(uint32) + if dv != nil { + *u = dv.(uint32) + } + *(fptr.(**uint32)) = u + case reflect.Uint64: + u := new(uint64) + if dv != nil { + *u = dv.(uint64) + } + *(fptr.(**uint64)) = u + default: + log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind) + } + } + + for _, ni := range dm.nested { + f := v.Field(ni) + // f is *T or []*T or map[T]*T + switch f.Kind() { + case reflect.Ptr: + if f.IsNil() { + continue + } + setDefaults(f, recur, zeros) + + case reflect.Slice: + for i := 0; i < f.Len(); i++ { + e := f.Index(i) + if e.IsNil() { + continue + } + setDefaults(e, recur, zeros) + } + + case reflect.Map: + for _, k := range f.MapKeys() { + e := f.MapIndex(k) + if e.IsNil() { + continue + } + setDefaults(e, recur, zeros) + } + } + } +} + +var ( + // defaults maps a protocol buffer struct type to a slice of the fields, + // with its scalar fields set to their proto-declared non-zero default values. + defaultMu sync.RWMutex + defaults = make(map[reflect.Type]defaultMessage) + + int32PtrType = reflect.TypeOf((*int32)(nil)) +) + +// defaultMessage represents information about the default values of a message. +type defaultMessage struct { + scalars []scalarField + nested []int // struct field index of nested messages +} + +type scalarField struct { + index int // struct field index + kind reflect.Kind // element type (the T in *T or []T) + value interface{} // the proto-declared default value, or nil +} + +// t is a struct type. +func buildDefaultMessage(t reflect.Type) (dm defaultMessage) { + sprop := GetProperties(t) + for _, prop := range sprop.Prop { + fi, ok := sprop.decoderTags.get(prop.Tag) + if !ok { + // XXX_unrecognized + continue + } + ft := t.Field(fi).Type + + sf, nested, err := fieldDefault(ft, prop) + switch { + case err != nil: + log.Print(err) + case nested: + dm.nested = append(dm.nested, fi) + case sf != nil: + sf.index = fi + dm.scalars = append(dm.scalars, *sf) + } + } + + return dm +} + +// fieldDefault returns the scalarField for field type ft. +// sf will be nil if the field can not have a default. +// nestedMessage will be true if this is a nested message. +// Note that sf.index is not set on return. +func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) { + var canHaveDefault bool + switch ft.Kind() { + case reflect.Ptr: + if ft.Elem().Kind() == reflect.Struct { + nestedMessage = true + } else { + canHaveDefault = true // proto2 scalar field + } + + case reflect.Slice: + switch ft.Elem().Kind() { + case reflect.Ptr: + nestedMessage = true // repeated message + case reflect.Uint8: + canHaveDefault = true // bytes field + } + + case reflect.Map: + if ft.Elem().Kind() == reflect.Ptr { + nestedMessage = true // map with message values + } + } + + if !canHaveDefault { + if nestedMessage { + return nil, true, nil + } + return nil, false, nil + } + + // We now know that ft is a pointer or slice. + sf = &scalarField{kind: ft.Elem().Kind()} + + // scalar fields without defaults + if !prop.HasDefault { + return sf, false, nil + } + + // a scalar field: either *T or []byte + switch ft.Elem().Kind() { + case reflect.Bool: + x, err := strconv.ParseBool(prop.Default) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err) + } + sf.value = x + case reflect.Float32: + x, err := strconv.ParseFloat(prop.Default, 32) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err) + } + sf.value = float32(x) + case reflect.Float64: + x, err := strconv.ParseFloat(prop.Default, 64) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err) + } + sf.value = x + case reflect.Int32: + x, err := strconv.ParseInt(prop.Default, 10, 32) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err) + } + sf.value = int32(x) + case reflect.Int64: + x, err := strconv.ParseInt(prop.Default, 10, 64) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err) + } + sf.value = x + case reflect.String: + sf.value = prop.Default + case reflect.Uint8: + // []byte (not *uint8) + sf.value = []byte(prop.Default) + case reflect.Uint32: + x, err := strconv.ParseUint(prop.Default, 10, 32) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err) + } + sf.value = uint32(x) + case reflect.Uint64: + x, err := strconv.ParseUint(prop.Default, 10, 64) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err) + } + sf.value = x + default: + return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind()) + } + + return sf, false, nil +} + +// Map fields may have key types of non-float scalars, strings and enums. +// The easiest way to sort them in some deterministic order is to use fmt. +// If this turns out to be inefficient we can always consider other options, +// such as doing a Schwartzian transform. + +func mapKeys(vs []reflect.Value) sort.Interface { + s := mapKeySorter{ + vs: vs, + // default Less function: textual comparison + less: func(a, b reflect.Value) bool { + return fmt.Sprint(a.Interface()) < fmt.Sprint(b.Interface()) + }, + } + + // Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps; + // numeric keys are sorted numerically. + if len(vs) == 0 { + return s + } + switch vs[0].Kind() { + case reflect.Int32, reflect.Int64: + s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() } + case reflect.Uint32, reflect.Uint64: + s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() } + } + + return s +} + +type mapKeySorter struct { + vs []reflect.Value + less func(a, b reflect.Value) bool +} + +func (s mapKeySorter) Len() int { return len(s.vs) } +func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] } +func (s mapKeySorter) Less(i, j int) bool { + return s.less(s.vs[i], s.vs[j]) +} + +// isProto3Zero reports whether v is a zero proto3 value. +func isProto3Zero(v reflect.Value) bool { + switch v.Kind() { + case reflect.Bool: + return !v.Bool() + case reflect.Int32, reflect.Int64: + return v.Int() == 0 + case reflect.Uint32, reflect.Uint64: + return v.Uint() == 0 + case reflect.Float32, reflect.Float64: + return v.Float() == 0 + case reflect.String: + return v.String() == "" + } + return false +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/lib_gogo.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/lib_gogo.go new file mode 100644 index 0000000000000000000000000000000000000000..a6c2c06b23de27f66f11bf2a1ccc16f750c9849f --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/lib_gogo.go @@ -0,0 +1,40 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 proto + +import ( + "encoding/json" + "strconv" +) + +func MarshalJSONEnum(m map[int32]string, value int32) ([]byte, error) { + s, ok := m[value] + if !ok { + s = strconv.Itoa(int(value)) + } + return json.Marshal(s) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/message_set.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/message_set.go new file mode 100644 index 0000000000000000000000000000000000000000..9d912bce19bb61f69634b9eb8ea64f69f9ddde63 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/message_set.go @@ -0,0 +1,287 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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 proto + +/* + * Support for message sets. + */ + +import ( + "bytes" + "encoding/json" + "errors" + "fmt" + "reflect" + "sort" +) + +// ErrNoMessageTypeId occurs when a protocol buffer does not have a message type ID. +// A message type ID is required for storing a protocol buffer in a message set. +var ErrNoMessageTypeId = errors.New("proto does not have a message type ID") + +// The first two types (_MessageSet_Item and MessageSet) +// model what the protocol compiler produces for the following protocol message: +// message MessageSet { +// repeated group Item = 1 { +// required int32 type_id = 2; +// required string message = 3; +// }; +// } +// That is the MessageSet wire format. We can't use a proto to generate these +// because that would introduce a circular dependency between it and this package. +// +// When a proto1 proto has a field that looks like: +// optional message info = 3; +// the protocol compiler produces a field in the generated struct that looks like: +// Info *_proto_.MessageSet `protobuf:"bytes,3,opt,name=info"` +// The package is automatically inserted so there is no need for that proto file to +// import this package. + +type _MessageSet_Item struct { + TypeId *int32 `protobuf:"varint,2,req,name=type_id"` + Message []byte `protobuf:"bytes,3,req,name=message"` +} + +type MessageSet struct { + Item []*_MessageSet_Item `protobuf:"group,1,rep"` + XXX_unrecognized []byte + // TODO: caching? +} + +// Make sure MessageSet is a Message. +var _ Message = (*MessageSet)(nil) + +// messageTypeIder is an interface satisfied by a protocol buffer type +// that may be stored in a MessageSet. +type messageTypeIder interface { + MessageTypeId() int32 +} + +func (ms *MessageSet) find(pb Message) *_MessageSet_Item { + mti, ok := pb.(messageTypeIder) + if !ok { + return nil + } + id := mti.MessageTypeId() + for _, item := range ms.Item { + if *item.TypeId == id { + return item + } + } + return nil +} + +func (ms *MessageSet) Has(pb Message) bool { + if ms.find(pb) != nil { + return true + } + return false +} + +func (ms *MessageSet) Unmarshal(pb Message) error { + if item := ms.find(pb); item != nil { + return Unmarshal(item.Message, pb) + } + if _, ok := pb.(messageTypeIder); !ok { + return ErrNoMessageTypeId + } + return nil // TODO: return error instead? +} + +func (ms *MessageSet) Marshal(pb Message) error { + msg, err := Marshal(pb) + if err != nil { + return err + } + if item := ms.find(pb); item != nil { + // reuse existing item + item.Message = msg + return nil + } + + mti, ok := pb.(messageTypeIder) + if !ok { + return ErrNoMessageTypeId + } + + mtid := mti.MessageTypeId() + ms.Item = append(ms.Item, &_MessageSet_Item{ + TypeId: &mtid, + Message: msg, + }) + return nil +} + +func (ms *MessageSet) Reset() { *ms = MessageSet{} } +func (ms *MessageSet) String() string { return CompactTextString(ms) } +func (*MessageSet) ProtoMessage() {} + +// Support for the message_set_wire_format message option. + +func skipVarint(buf []byte) []byte { + i := 0 + for ; buf[i]&0x80 != 0; i++ { + } + return buf[i+1:] +} + +// MarshalMessageSet encodes the extension map represented by m in the message set wire format. +// It is called by generated Marshal methods on protocol buffer messages with the message_set_wire_format option. +func MarshalMessageSet(m map[int32]Extension) ([]byte, error) { + if err := encodeExtensionMap(m); err != nil { + return nil, err + } + + // Sort extension IDs to provide a deterministic encoding. + // See also enc_map in encode.go. + ids := make([]int, 0, len(m)) + for id := range m { + ids = append(ids, int(id)) + } + sort.Ints(ids) + + ms := &MessageSet{Item: make([]*_MessageSet_Item, 0, len(m))} + for _, id := range ids { + e := m[int32(id)] + // Remove the wire type and field number varint, as well as the length varint. + msg := skipVarint(skipVarint(e.enc)) + + ms.Item = append(ms.Item, &_MessageSet_Item{ + TypeId: Int32(int32(id)), + Message: msg, + }) + } + return Marshal(ms) +} + +// UnmarshalMessageSet decodes the extension map encoded in buf in the message set wire format. +// It is called by generated Unmarshal methods on protocol buffer messages with the message_set_wire_format option. +func UnmarshalMessageSet(buf []byte, m map[int32]Extension) error { + ms := new(MessageSet) + if err := Unmarshal(buf, ms); err != nil { + return err + } + for _, item := range ms.Item { + id := *item.TypeId + msg := item.Message + + // Restore wire type and field number varint, plus length varint. + // Be careful to preserve duplicate items. + b := EncodeVarint(uint64(id)<<3 | WireBytes) + if ext, ok := m[id]; ok { + // Existing data; rip off the tag and length varint + // so we join the new data correctly. + // We can assume that ext.enc is set because we are unmarshaling. + o := ext.enc[len(b):] // skip wire type and field number + _, n := DecodeVarint(o) // calculate length of length varint + o = o[n:] // skip length varint + msg = append(o, msg...) // join old data and new data + } + b = append(b, EncodeVarint(uint64(len(msg)))...) + b = append(b, msg...) + + m[id] = Extension{enc: b} + } + return nil +} + +// MarshalMessageSetJSON encodes the extension map represented by m in JSON format. +// It is called by generated MarshalJSON methods on protocol buffer messages with the message_set_wire_format option. +func MarshalMessageSetJSON(m map[int32]Extension) ([]byte, error) { + var b bytes.Buffer + b.WriteByte('{') + + // Process the map in key order for deterministic output. + ids := make([]int32, 0, len(m)) + for id := range m { + ids = append(ids, id) + } + sort.Sort(int32Slice(ids)) // int32Slice defined in text.go + + for i, id := range ids { + ext := m[id] + if i > 0 { + b.WriteByte(',') + } + + msd, ok := messageSetMap[id] + if !ok { + // Unknown type; we can't render it, so skip it. + continue + } + fmt.Fprintf(&b, `"[%s]":`, msd.name) + + x := ext.value + if x == nil { + x = reflect.New(msd.t.Elem()).Interface() + if err := Unmarshal(ext.enc, x.(Message)); err != nil { + return nil, err + } + } + d, err := json.Marshal(x) + if err != nil { + return nil, err + } + b.Write(d) + } + b.WriteByte('}') + return b.Bytes(), nil +} + +// UnmarshalMessageSetJSON decodes the extension map encoded in buf in JSON format. +// It is called by generated UnmarshalJSON methods on protocol buffer messages with the message_set_wire_format option. +func UnmarshalMessageSetJSON(buf []byte, m map[int32]Extension) error { + // Common-case fast path. + if len(buf) == 0 || bytes.Equal(buf, []byte("{}")) { + return nil + } + + // This is fairly tricky, and it's not clear that it is needed. + return errors.New("TODO: UnmarshalMessageSetJSON not yet implemented") +} + +// A global registry of types that can be used in a MessageSet. + +var messageSetMap = make(map[int32]messageSetDesc) + +type messageSetDesc struct { + t reflect.Type // pointer to struct + name string +} + +// RegisterMessageSetType is called from the generated code. +func RegisterMessageSetType(m Message, fieldNum int32, name string) { + messageSetMap[fieldNum] = messageSetDesc{ + t: reflect.TypeOf(m), + name: name, + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/message_set_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/message_set_test.go new file mode 100644 index 0000000000000000000000000000000000000000..7c29bccf4b1d9d0844cf2e58ffd3e7370878b5f5 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/message_set_test.go @@ -0,0 +1,66 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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 proto + +import ( + "bytes" + "testing" +) + +func TestUnmarshalMessageSetWithDuplicate(t *testing.T) { + // Check that a repeated message set entry will be concatenated. + in := &MessageSet{ + Item: []*_MessageSet_Item{ + {TypeId: Int32(12345), Message: []byte("hoo")}, + {TypeId: Int32(12345), Message: []byte("hah")}, + }, + } + b, err := Marshal(in) + if err != nil { + t.Fatalf("Marshal: %v", err) + } + t.Logf("Marshaled bytes: %q", b) + + m := make(map[int32]Extension) + if err := UnmarshalMessageSet(b, m); err != nil { + t.Fatalf("UnmarshalMessageSet: %v", err) + } + ext, ok := m[12345] + if !ok { + t.Fatalf("Didn't retrieve extension 12345; map is %v", m) + } + // Skip wire type/field number and length varints. + got := skipVarint(skipVarint(ext.enc)) + if want := []byte("hoohah"); !bytes.Equal(got, want) { + t.Errorf("Combined extension is %q, want %q", got, want) + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/pointer_reflect.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/pointer_reflect.go new file mode 100644 index 0000000000000000000000000000000000000000..749919d250a1acffc5588a004501ee6b829d9059 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/pointer_reflect.go @@ -0,0 +1,479 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2012 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. + +// +build appengine + +// This file contains an implementation of proto field accesses using package reflect. +// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can +// be used on App Engine. + +package proto + +import ( + "math" + "reflect" +) + +// A structPointer is a pointer to a struct. +type structPointer struct { + v reflect.Value +} + +// toStructPointer returns a structPointer equivalent to the given reflect value. +// The reflect value must itself be a pointer to a struct. +func toStructPointer(v reflect.Value) structPointer { + return structPointer{v} +} + +// IsNil reports whether p is nil. +func structPointer_IsNil(p structPointer) bool { + return p.v.IsNil() +} + +// Interface returns the struct pointer as an interface value. +func structPointer_Interface(p structPointer, _ reflect.Type) interface{} { + return p.v.Interface() +} + +// A field identifies a field in a struct, accessible from a structPointer. +// In this implementation, a field is identified by the sequence of field indices +// passed to reflect's FieldByIndex. +type field []int + +// toField returns a field equivalent to the given reflect field. +func toField(f *reflect.StructField) field { + return f.Index +} + +// invalidField is an invalid field identifier. +var invalidField = field(nil) + +// IsValid reports whether the field identifier is valid. +func (f field) IsValid() bool { return f != nil } + +// field returns the given field in the struct as a reflect value. +func structPointer_field(p structPointer, f field) reflect.Value { + // Special case: an extension map entry with a value of type T + // passes a *T to the struct-handling code with a zero field, + // expecting that it will be treated as equivalent to *struct{ X T }, + // which has the same memory layout. We have to handle that case + // specially, because reflect will panic if we call FieldByIndex on a + // non-struct. + if f == nil { + return p.v.Elem() + } + + return p.v.Elem().FieldByIndex(f) +} + +// ifield returns the given field in the struct as an interface value. +func structPointer_ifield(p structPointer, f field) interface{} { + return structPointer_field(p, f).Addr().Interface() +} + +// Bytes returns the address of a []byte field in the struct. +func structPointer_Bytes(p structPointer, f field) *[]byte { + return structPointer_ifield(p, f).(*[]byte) +} + +// BytesSlice returns the address of a [][]byte field in the struct. +func structPointer_BytesSlice(p structPointer, f field) *[][]byte { + return structPointer_ifield(p, f).(*[][]byte) +} + +// Bool returns the address of a *bool field in the struct. +func structPointer_Bool(p structPointer, f field) **bool { + return structPointer_ifield(p, f).(**bool) +} + +// BoolVal returns the address of a bool field in the struct. +func structPointer_BoolVal(p structPointer, f field) *bool { + return structPointer_ifield(p, f).(*bool) +} + +// BoolSlice returns the address of a []bool field in the struct. +func structPointer_BoolSlice(p structPointer, f field) *[]bool { + return structPointer_ifield(p, f).(*[]bool) +} + +// String returns the address of a *string field in the struct. +func structPointer_String(p structPointer, f field) **string { + return structPointer_ifield(p, f).(**string) +} + +// StringVal returns the address of a string field in the struct. +func structPointer_StringVal(p structPointer, f field) *string { + return structPointer_ifield(p, f).(*string) +} + +// StringSlice returns the address of a []string field in the struct. +func structPointer_StringSlice(p structPointer, f field) *[]string { + return structPointer_ifield(p, f).(*[]string) +} + +// ExtMap returns the address of an extension map field in the struct. +func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension { + return structPointer_ifield(p, f).(*map[int32]Extension) +} + +// NewAt returns the reflect.Value for a pointer to a field in the struct. +func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value { + return structPointer_field(p, f).Addr() +} + +// SetStructPointer writes a *struct field in the struct. +func structPointer_SetStructPointer(p structPointer, f field, q structPointer) { + structPointer_field(p, f).Set(q.v) +} + +// GetStructPointer reads a *struct field in the struct. +func structPointer_GetStructPointer(p structPointer, f field) structPointer { + return structPointer{structPointer_field(p, f)} +} + +// StructPointerSlice the address of a []*struct field in the struct. +func structPointer_StructPointerSlice(p structPointer, f field) structPointerSlice { + return structPointerSlice{structPointer_field(p, f)} +} + +// A structPointerSlice represents the address of a slice of pointers to structs +// (themselves messages or groups). That is, v.Type() is *[]*struct{...}. +type structPointerSlice struct { + v reflect.Value +} + +func (p structPointerSlice) Len() int { return p.v.Len() } +func (p structPointerSlice) Index(i int) structPointer { return structPointer{p.v.Index(i)} } +func (p structPointerSlice) Append(q structPointer) { + p.v.Set(reflect.Append(p.v, q.v)) +} + +var ( + int32Type = reflect.TypeOf(int32(0)) + uint32Type = reflect.TypeOf(uint32(0)) + float32Type = reflect.TypeOf(float32(0)) + int64Type = reflect.TypeOf(int64(0)) + uint64Type = reflect.TypeOf(uint64(0)) + float64Type = reflect.TypeOf(float64(0)) +) + +// A word32 represents a field of type *int32, *uint32, *float32, or *enum. +// That is, v.Type() is *int32, *uint32, *float32, or *enum and v is assignable. +type word32 struct { + v reflect.Value +} + +// IsNil reports whether p is nil. +func word32_IsNil(p word32) bool { + return p.v.IsNil() +} + +// Set sets p to point at a newly allocated word with bits set to x. +func word32_Set(p word32, o *Buffer, x uint32) { + t := p.v.Type().Elem() + switch t { + case int32Type: + if len(o.int32s) == 0 { + o.int32s = make([]int32, uint32PoolSize) + } + o.int32s[0] = int32(x) + p.v.Set(reflect.ValueOf(&o.int32s[0])) + o.int32s = o.int32s[1:] + return + case uint32Type: + if len(o.uint32s) == 0 { + o.uint32s = make([]uint32, uint32PoolSize) + } + o.uint32s[0] = x + p.v.Set(reflect.ValueOf(&o.uint32s[0])) + o.uint32s = o.uint32s[1:] + return + case float32Type: + if len(o.float32s) == 0 { + o.float32s = make([]float32, uint32PoolSize) + } + o.float32s[0] = math.Float32frombits(x) + p.v.Set(reflect.ValueOf(&o.float32s[0])) + o.float32s = o.float32s[1:] + return + } + + // must be enum + p.v.Set(reflect.New(t)) + p.v.Elem().SetInt(int64(int32(x))) +} + +// Get gets the bits pointed at by p, as a uint32. +func word32_Get(p word32) uint32 { + elem := p.v.Elem() + switch elem.Kind() { + case reflect.Int32: + return uint32(elem.Int()) + case reflect.Uint32: + return uint32(elem.Uint()) + case reflect.Float32: + return math.Float32bits(float32(elem.Float())) + } + panic("unreachable") +} + +// Word32 returns a reference to a *int32, *uint32, *float32, or *enum field in the struct. +func structPointer_Word32(p structPointer, f field) word32 { + return word32{structPointer_field(p, f)} +} + +// A word32Val represents a field of type int32, uint32, float32, or enum. +// That is, v.Type() is int32, uint32, float32, or enum and v is assignable. +type word32Val struct { + v reflect.Value +} + +// Set sets *p to x. +func word32Val_Set(p word32Val, x uint32) { + switch p.v.Type() { + case int32Type: + p.v.SetInt(int64(x)) + return + case uint32Type: + p.v.SetUint(uint64(x)) + return + case float32Type: + p.v.SetFloat(float64(math.Float32frombits(x))) + return + } + + // must be enum + p.v.SetInt(int64(int32(x))) +} + +// Get gets the bits pointed at by p, as a uint32. +func word32Val_Get(p word32Val) uint32 { + elem := p.v + switch elem.Kind() { + case reflect.Int32: + return uint32(elem.Int()) + case reflect.Uint32: + return uint32(elem.Uint()) + case reflect.Float32: + return math.Float32bits(float32(elem.Float())) + } + panic("unreachable") +} + +// Word32Val returns a reference to a int32, uint32, float32, or enum field in the struct. +func structPointer_Word32Val(p structPointer, f field) word32Val { + return word32Val{structPointer_field(p, f)} +} + +// A word32Slice is a slice of 32-bit values. +// That is, v.Type() is []int32, []uint32, []float32, or []enum. +type word32Slice struct { + v reflect.Value +} + +func (p word32Slice) Append(x uint32) { + n, m := p.v.Len(), p.v.Cap() + if n < m { + p.v.SetLen(n + 1) + } else { + t := p.v.Type().Elem() + p.v.Set(reflect.Append(p.v, reflect.Zero(t))) + } + elem := p.v.Index(n) + switch elem.Kind() { + case reflect.Int32: + elem.SetInt(int64(int32(x))) + case reflect.Uint32: + elem.SetUint(uint64(x)) + case reflect.Float32: + elem.SetFloat(float64(math.Float32frombits(x))) + } +} + +func (p word32Slice) Len() int { + return p.v.Len() +} + +func (p word32Slice) Index(i int) uint32 { + elem := p.v.Index(i) + switch elem.Kind() { + case reflect.Int32: + return uint32(elem.Int()) + case reflect.Uint32: + return uint32(elem.Uint()) + case reflect.Float32: + return math.Float32bits(float32(elem.Float())) + } + panic("unreachable") +} + +// Word32Slice returns a reference to a []int32, []uint32, []float32, or []enum field in the struct. +func structPointer_Word32Slice(p structPointer, f field) word32Slice { + return word32Slice{structPointer_field(p, f)} +} + +// word64 is like word32 but for 64-bit values. +type word64 struct { + v reflect.Value +} + +func word64_Set(p word64, o *Buffer, x uint64) { + t := p.v.Type().Elem() + switch t { + case int64Type: + if len(o.int64s) == 0 { + o.int64s = make([]int64, uint64PoolSize) + } + o.int64s[0] = int64(x) + p.v.Set(reflect.ValueOf(&o.int64s[0])) + o.int64s = o.int64s[1:] + return + case uint64Type: + if len(o.uint64s) == 0 { + o.uint64s = make([]uint64, uint64PoolSize) + } + o.uint64s[0] = x + p.v.Set(reflect.ValueOf(&o.uint64s[0])) + o.uint64s = o.uint64s[1:] + return + case float64Type: + if len(o.float64s) == 0 { + o.float64s = make([]float64, uint64PoolSize) + } + o.float64s[0] = math.Float64frombits(x) + p.v.Set(reflect.ValueOf(&o.float64s[0])) + o.float64s = o.float64s[1:] + return + } + panic("unreachable") +} + +func word64_IsNil(p word64) bool { + return p.v.IsNil() +} + +func word64_Get(p word64) uint64 { + elem := p.v.Elem() + switch elem.Kind() { + case reflect.Int64: + return uint64(elem.Int()) + case reflect.Uint64: + return elem.Uint() + case reflect.Float64: + return math.Float64bits(elem.Float()) + } + panic("unreachable") +} + +func structPointer_Word64(p structPointer, f field) word64 { + return word64{structPointer_field(p, f)} +} + +// word64Val is like word32Val but for 64-bit values. +type word64Val struct { + v reflect.Value +} + +func word64Val_Set(p word64Val, o *Buffer, x uint64) { + switch p.v.Type() { + case int64Type: + p.v.SetInt(int64(x)) + return + case uint64Type: + p.v.SetUint(x) + return + case float64Type: + p.v.SetFloat(math.Float64frombits(x)) + return + } + panic("unreachable") +} + +func word64Val_Get(p word64Val) uint64 { + elem := p.v + switch elem.Kind() { + case reflect.Int64: + return uint64(elem.Int()) + case reflect.Uint64: + return elem.Uint() + case reflect.Float64: + return math.Float64bits(elem.Float()) + } + panic("unreachable") +} + +func structPointer_Word64Val(p structPointer, f field) word64Val { + return word64Val{structPointer_field(p, f)} +} + +type word64Slice struct { + v reflect.Value +} + +func (p word64Slice) Append(x uint64) { + n, m := p.v.Len(), p.v.Cap() + if n < m { + p.v.SetLen(n + 1) + } else { + t := p.v.Type().Elem() + p.v.Set(reflect.Append(p.v, reflect.Zero(t))) + } + elem := p.v.Index(n) + switch elem.Kind() { + case reflect.Int64: + elem.SetInt(int64(int64(x))) + case reflect.Uint64: + elem.SetUint(uint64(x)) + case reflect.Float64: + elem.SetFloat(float64(math.Float64frombits(x))) + } +} + +func (p word64Slice) Len() int { + return p.v.Len() +} + +func (p word64Slice) Index(i int) uint64 { + elem := p.v.Index(i) + switch elem.Kind() { + case reflect.Int64: + return uint64(elem.Int()) + case reflect.Uint64: + return uint64(elem.Uint()) + case reflect.Float64: + return math.Float64bits(float64(elem.Float())) + } + panic("unreachable") +} + +func structPointer_Word64Slice(p structPointer, f field) word64Slice { + return word64Slice{structPointer_field(p, f)} +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/pointer_unsafe.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/pointer_unsafe.go new file mode 100644 index 0000000000000000000000000000000000000000..e9be0fe92ee708ad56688e024dadb2b21821be8c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/pointer_unsafe.go @@ -0,0 +1,266 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2012 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. + +// +build !appengine + +// This file contains the implementation of the proto field accesses using package unsafe. + +package proto + +import ( + "reflect" + "unsafe" +) + +// NOTE: These type_Foo functions would more idiomatically be methods, +// but Go does not allow methods on pointer types, and we must preserve +// some pointer type for the garbage collector. We use these +// funcs with clunky names as our poor approximation to methods. +// +// An alternative would be +// type structPointer struct { p unsafe.Pointer } +// but that does not registerize as well. + +// A structPointer is a pointer to a struct. +type structPointer unsafe.Pointer + +// toStructPointer returns a structPointer equivalent to the given reflect value. +func toStructPointer(v reflect.Value) structPointer { + return structPointer(unsafe.Pointer(v.Pointer())) +} + +// IsNil reports whether p is nil. +func structPointer_IsNil(p structPointer) bool { + return p == nil +} + +// Interface returns the struct pointer, assumed to have element type t, +// as an interface value. +func structPointer_Interface(p structPointer, t reflect.Type) interface{} { + return reflect.NewAt(t, unsafe.Pointer(p)).Interface() +} + +// A field identifies a field in a struct, accessible from a structPointer. +// In this implementation, a field is identified by its byte offset from the start of the struct. +type field uintptr + +// toField returns a field equivalent to the given reflect field. +func toField(f *reflect.StructField) field { + return field(f.Offset) +} + +// invalidField is an invalid field identifier. +const invalidField = ^field(0) + +// IsValid reports whether the field identifier is valid. +func (f field) IsValid() bool { + return f != ^field(0) +} + +// Bytes returns the address of a []byte field in the struct. +func structPointer_Bytes(p structPointer, f field) *[]byte { + return (*[]byte)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// BytesSlice returns the address of a [][]byte field in the struct. +func structPointer_BytesSlice(p structPointer, f field) *[][]byte { + return (*[][]byte)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// Bool returns the address of a *bool field in the struct. +func structPointer_Bool(p structPointer, f field) **bool { + return (**bool)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// BoolVal returns the address of a bool field in the struct. +func structPointer_BoolVal(p structPointer, f field) *bool { + return (*bool)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// BoolSlice returns the address of a []bool field in the struct. +func structPointer_BoolSlice(p structPointer, f field) *[]bool { + return (*[]bool)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// String returns the address of a *string field in the struct. +func structPointer_String(p structPointer, f field) **string { + return (**string)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// StringVal returns the address of a string field in the struct. +func structPointer_StringVal(p structPointer, f field) *string { + return (*string)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// StringSlice returns the address of a []string field in the struct. +func structPointer_StringSlice(p structPointer, f field) *[]string { + return (*[]string)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// ExtMap returns the address of an extension map field in the struct. +func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension { + return (*map[int32]Extension)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// NewAt returns the reflect.Value for a pointer to a field in the struct. +func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value { + return reflect.NewAt(typ, unsafe.Pointer(uintptr(p)+uintptr(f))) +} + +// SetStructPointer writes a *struct field in the struct. +func structPointer_SetStructPointer(p structPointer, f field, q structPointer) { + *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))) = q +} + +// GetStructPointer reads a *struct field in the struct. +func structPointer_GetStructPointer(p structPointer, f field) structPointer { + return *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// StructPointerSlice the address of a []*struct field in the struct. +func structPointer_StructPointerSlice(p structPointer, f field) *structPointerSlice { + return (*structPointerSlice)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// A structPointerSlice represents a slice of pointers to structs (themselves submessages or groups). +type structPointerSlice []structPointer + +func (v *structPointerSlice) Len() int { return len(*v) } +func (v *structPointerSlice) Index(i int) structPointer { return (*v)[i] } +func (v *structPointerSlice) Append(p structPointer) { *v = append(*v, p) } + +// A word32 is the address of a "pointer to 32-bit value" field. +type word32 **uint32 + +// IsNil reports whether *v is nil. +func word32_IsNil(p word32) bool { + return *p == nil +} + +// Set sets *v to point at a newly allocated word set to x. +func word32_Set(p word32, o *Buffer, x uint32) { + if len(o.uint32s) == 0 { + o.uint32s = make([]uint32, uint32PoolSize) + } + o.uint32s[0] = x + *p = &o.uint32s[0] + o.uint32s = o.uint32s[1:] +} + +// Get gets the value pointed at by *v. +func word32_Get(p word32) uint32 { + return **p +} + +// Word32 returns the address of a *int32, *uint32, *float32, or *enum field in the struct. +func structPointer_Word32(p structPointer, f field) word32 { + return word32((**uint32)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +// A word32Val is the address of a 32-bit value field. +type word32Val *uint32 + +// Set sets *p to x. +func word32Val_Set(p word32Val, x uint32) { + *p = x +} + +// Get gets the value pointed at by p. +func word32Val_Get(p word32Val) uint32 { + return *p +} + +// Word32Val returns the address of a *int32, *uint32, *float32, or *enum field in the struct. +func structPointer_Word32Val(p structPointer, f field) word32Val { + return word32Val((*uint32)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +// A word32Slice is a slice of 32-bit values. +type word32Slice []uint32 + +func (v *word32Slice) Append(x uint32) { *v = append(*v, x) } +func (v *word32Slice) Len() int { return len(*v) } +func (v *word32Slice) Index(i int) uint32 { return (*v)[i] } + +// Word32Slice returns the address of a []int32, []uint32, []float32, or []enum field in the struct. +func structPointer_Word32Slice(p structPointer, f field) *word32Slice { + return (*word32Slice)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// word64 is like word32 but for 64-bit values. +type word64 **uint64 + +func word64_Set(p word64, o *Buffer, x uint64) { + if len(o.uint64s) == 0 { + o.uint64s = make([]uint64, uint64PoolSize) + } + o.uint64s[0] = x + *p = &o.uint64s[0] + o.uint64s = o.uint64s[1:] +} + +func word64_IsNil(p word64) bool { + return *p == nil +} + +func word64_Get(p word64) uint64 { + return **p +} + +func structPointer_Word64(p structPointer, f field) word64 { + return word64((**uint64)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +// word64Val is like word32Val but for 64-bit values. +type word64Val *uint64 + +func word64Val_Set(p word64Val, o *Buffer, x uint64) { + *p = x +} + +func word64Val_Get(p word64Val) uint64 { + return *p +} + +func structPointer_Word64Val(p structPointer, f field) word64Val { + return word64Val((*uint64)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +// word64Slice is like word32Slice but for 64-bit values. +type word64Slice []uint64 + +func (v *word64Slice) Append(x uint64) { *v = append(*v, x) } +func (v *word64Slice) Len() int { return len(*v) } +func (v *word64Slice) Index(i int) uint64 { return (*v)[i] } + +func structPointer_Word64Slice(p structPointer, f field) *word64Slice { + return (*word64Slice)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/pointer_unsafe_gogo.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/pointer_unsafe_gogo.go new file mode 100644 index 0000000000000000000000000000000000000000..6bc85fa9873f49ba21b030ab28ed2220f15bb1a0 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/pointer_unsafe_gogo.go @@ -0,0 +1,108 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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. + +// +build !appengine + +// This file contains the implementation of the proto field accesses using package unsafe. + +package proto + +import ( + "reflect" + "unsafe" +) + +func structPointer_InterfaceAt(p structPointer, f field, t reflect.Type) interface{} { + point := unsafe.Pointer(uintptr(p) + uintptr(f)) + r := reflect.NewAt(t, point) + return r.Interface() +} + +func structPointer_InterfaceRef(p structPointer, f field, t reflect.Type) interface{} { + point := unsafe.Pointer(uintptr(p) + uintptr(f)) + r := reflect.NewAt(t, point) + if r.Elem().IsNil() { + return nil + } + return r.Elem().Interface() +} + +func copyUintPtr(oldptr, newptr uintptr, size int) { + oldbytes := make([]byte, 0) + oldslice := (*reflect.SliceHeader)(unsafe.Pointer(&oldbytes)) + oldslice.Data = oldptr + oldslice.Len = size + oldslice.Cap = size + newbytes := make([]byte, 0) + newslice := (*reflect.SliceHeader)(unsafe.Pointer(&newbytes)) + newslice.Data = newptr + newslice.Len = size + newslice.Cap = size + copy(newbytes, oldbytes) +} + +func structPointer_Copy(oldptr structPointer, newptr structPointer, size int) { + copyUintPtr(uintptr(oldptr), uintptr(newptr), size) +} + +func appendStructPointer(base structPointer, f field, typ reflect.Type) structPointer { + size := typ.Elem().Size() + oldHeader := structPointer_GetSliceHeader(base, f) + newLen := oldHeader.Len + 1 + slice := reflect.MakeSlice(typ, newLen, newLen) + bas := toStructPointer(slice) + for i := 0; i < oldHeader.Len; i++ { + newElemptr := uintptr(bas) + uintptr(i)*size + oldElemptr := oldHeader.Data + uintptr(i)*size + copyUintPtr(oldElemptr, newElemptr, int(size)) + } + + oldHeader.Data = uintptr(bas) + oldHeader.Len = newLen + oldHeader.Cap = newLen + + return structPointer(unsafe.Pointer(uintptr(unsafe.Pointer(bas)) + uintptr(uintptr(newLen-1)*size))) +} + +func structPointer_FieldPointer(p structPointer, f field) structPointer { + return structPointer(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +func structPointer_GetRefStructPointer(p structPointer, f field) structPointer { + return structPointer((*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +func structPointer_GetSliceHeader(p structPointer, f field) *reflect.SliceHeader { + return (*reflect.SliceHeader)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +func structPointer_Add(p structPointer, size field) structPointer { + return structPointer(unsafe.Pointer(uintptr(p) + uintptr(size))) +} + +func structPointer_Len(p structPointer, f field) int { + return len(*(*[]interface{})(unsafe.Pointer(structPointer_GetRefStructPointer(p, f)))) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/properties.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/properties.go new file mode 100644 index 0000000000000000000000000000000000000000..6fb7e41e971df95104db42ba788392c7411d870d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/properties.go @@ -0,0 +1,882 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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 proto + +/* + * Routines for encoding data into the wire format for protocol buffers. + */ + +import ( + "fmt" + "os" + "reflect" + "sort" + "strconv" + "strings" + "sync" +) + +const debug bool = false + +// Constants that identify the encoding of a value on the wire. +const ( + WireVarint = 0 + WireFixed64 = 1 + WireBytes = 2 + WireStartGroup = 3 + WireEndGroup = 4 + WireFixed32 = 5 +) + +const startSize = 10 // initial slice/string sizes + +// Encoders are defined in encode.go +// An encoder outputs the full representation of a field, including its +// tag and encoder type. +type encoder func(p *Buffer, prop *Properties, base structPointer) error + +// A valueEncoder encodes a single integer in a particular encoding. +type valueEncoder func(o *Buffer, x uint64) error + +// Sizers are defined in encode.go +// A sizer returns the encoded size of a field, including its tag and encoder +// type. +type sizer func(prop *Properties, base structPointer) int + +// A valueSizer returns the encoded size of a single integer in a particular +// encoding. +type valueSizer func(x uint64) int + +// Decoders are defined in decode.go +// A decoder creates a value from its wire representation. +// Unrecognized subelements are saved in unrec. +type decoder func(p *Buffer, prop *Properties, base structPointer) error + +// A valueDecoder decodes a single integer in a particular encoding. +type valueDecoder func(o *Buffer) (x uint64, err error) + +// A oneofMarshaler does the marshaling for all oneof fields in a message. +type oneofMarshaler func(Message, *Buffer) error + +// A oneofUnmarshaler does the unmarshaling for a oneof field in a message. +type oneofUnmarshaler func(Message, int, int, *Buffer) (bool, error) + +// tagMap is an optimization over map[int]int for typical protocol buffer +// use-cases. Encoded protocol buffers are often in tag order with small tag +// numbers. +type tagMap struct { + fastTags []int + slowTags map[int]int +} + +// tagMapFastLimit is the upper bound on the tag number that will be stored in +// the tagMap slice rather than its map. +const tagMapFastLimit = 1024 + +func (p *tagMap) get(t int) (int, bool) { + if t > 0 && t < tagMapFastLimit { + if t >= len(p.fastTags) { + return 0, false + } + fi := p.fastTags[t] + return fi, fi >= 0 + } + fi, ok := p.slowTags[t] + return fi, ok +} + +func (p *tagMap) put(t int, fi int) { + if t > 0 && t < tagMapFastLimit { + for len(p.fastTags) < t+1 { + p.fastTags = append(p.fastTags, -1) + } + p.fastTags[t] = fi + return + } + if p.slowTags == nil { + p.slowTags = make(map[int]int) + } + p.slowTags[t] = fi +} + +// StructProperties represents properties for all the fields of a struct. +// decoderTags and decoderOrigNames should only be used by the decoder. +type StructProperties struct { + Prop []*Properties // properties for each field + reqCount int // required count + decoderTags tagMap // map from proto tag to struct field number + decoderOrigNames map[string]int // map from original name to struct field number + order []int // list of struct field numbers in tag order + unrecField field // field id of the XXX_unrecognized []byte field + extendable bool // is this an extendable proto + + oneofMarshaler oneofMarshaler + oneofUnmarshaler oneofUnmarshaler + stype reflect.Type + + // OneofTypes contains information about the oneof fields in this message. + // It is keyed by the original name of a field. + OneofTypes map[string]*OneofProperties +} + +// OneofProperties represents information about a specific field in a oneof. +type OneofProperties struct { + Type reflect.Type // pointer to generated struct type for this oneof field + Field int // struct field number of the containing oneof in the message + Prop *Properties +} + +// Implement the sorting interface so we can sort the fields in tag order, as recommended by the spec. +// See encode.go, (*Buffer).enc_struct. + +func (sp *StructProperties) Len() int { return len(sp.order) } +func (sp *StructProperties) Less(i, j int) bool { + return sp.Prop[sp.order[i]].Tag < sp.Prop[sp.order[j]].Tag +} +func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order[j], sp.order[i] } + +// Properties represents the protocol-specific behavior of a single struct field. +type Properties struct { + Name string // name of the field, for error messages + OrigName string // original name before protocol compiler (always set) + Wire string + WireType int + Tag int + Required bool + Optional bool + Repeated bool + Packed bool // relevant for repeated primitives only + Enum string // set for enum types only + proto3 bool // whether this is known to be a proto3 field; set for []byte only + oneof bool // whether this is a oneof field + + Default string // default value + HasDefault bool // whether an explicit default was provided + CustomType string + def_uint64 uint64 + + enc encoder + valEnc valueEncoder // set for bool and numeric types only + field field + tagcode []byte // encoding of EncodeVarint((Tag<<3)|WireType) + tagbuf [8]byte + stype reflect.Type // set for struct types only + sstype reflect.Type // set for slices of structs types only + ctype reflect.Type // set for custom types only + sprop *StructProperties // set for struct types only + isMarshaler bool + isUnmarshaler bool + + mtype reflect.Type // set for map types only + mkeyprop *Properties // set for map types only + mvalprop *Properties // set for map types only + + size sizer + valSize valueSizer // set for bool and numeric types only + + dec decoder + valDec valueDecoder // set for bool and numeric types only + + // If this is a packable field, this will be the decoder for the packed version of the field. + packedDec decoder +} + +// String formats the properties in the protobuf struct field tag style. +func (p *Properties) String() string { + s := p.Wire + s = "," + s += strconv.Itoa(p.Tag) + if p.Required { + s += ",req" + } + if p.Optional { + s += ",opt" + } + if p.Repeated { + s += ",rep" + } + if p.Packed { + s += ",packed" + } + if p.OrigName != p.Name { + s += ",name=" + p.OrigName + } + if p.proto3 { + s += ",proto3" + } + if p.oneof { + s += ",oneof" + } + if len(p.Enum) > 0 { + s += ",enum=" + p.Enum + } + if p.HasDefault { + s += ",def=" + p.Default + } + return s +} + +// Parse populates p by parsing a string in the protobuf struct field tag style. +func (p *Properties) Parse(s string) { + // "bytes,49,opt,name=foo,def=hello!" + fields := strings.Split(s, ",") // breaks def=, but handled below. + if len(fields) < 2 { + fmt.Fprintf(os.Stderr, "proto: tag has too few fields: %q\n", s) + return + } + + p.Wire = fields[0] + switch p.Wire { + case "varint": + p.WireType = WireVarint + p.valEnc = (*Buffer).EncodeVarint + p.valDec = (*Buffer).DecodeVarint + p.valSize = sizeVarint + case "fixed32": + p.WireType = WireFixed32 + p.valEnc = (*Buffer).EncodeFixed32 + p.valDec = (*Buffer).DecodeFixed32 + p.valSize = sizeFixed32 + case "fixed64": + p.WireType = WireFixed64 + p.valEnc = (*Buffer).EncodeFixed64 + p.valDec = (*Buffer).DecodeFixed64 + p.valSize = sizeFixed64 + case "zigzag32": + p.WireType = WireVarint + p.valEnc = (*Buffer).EncodeZigzag32 + p.valDec = (*Buffer).DecodeZigzag32 + p.valSize = sizeZigzag32 + case "zigzag64": + p.WireType = WireVarint + p.valEnc = (*Buffer).EncodeZigzag64 + p.valDec = (*Buffer).DecodeZigzag64 + p.valSize = sizeZigzag64 + case "bytes", "group": + p.WireType = WireBytes + // no numeric converter for non-numeric types + default: + fmt.Fprintf(os.Stderr, "proto: tag has unknown wire type: %q\n", s) + return + } + + var err error + p.Tag, err = strconv.Atoi(fields[1]) + if err != nil { + return + } + + for i := 2; i < len(fields); i++ { + f := fields[i] + switch { + case f == "req": + p.Required = true + case f == "opt": + p.Optional = true + case f == "rep": + p.Repeated = true + case f == "packed": + p.Packed = true + case strings.HasPrefix(f, "name="): + p.OrigName = f[5:] + case strings.HasPrefix(f, "enum="): + p.Enum = f[5:] + case f == "proto3": + p.proto3 = true + case f == "oneof": + p.oneof = true + case strings.HasPrefix(f, "def="): + p.HasDefault = true + p.Default = f[4:] // rest of string + if i+1 < len(fields) { + // Commas aren't escaped, and def is always last. + p.Default += "," + strings.Join(fields[i+1:], ",") + break + } + case strings.HasPrefix(f, "embedded="): + p.OrigName = strings.Split(f, "=")[1] + case strings.HasPrefix(f, "customtype="): + p.CustomType = strings.Split(f, "=")[1] + } + } +} + +func logNoSliceEnc(t1, t2 reflect.Type) { + fmt.Fprintf(os.Stderr, "proto: no slice oenc for %T = []%T\n", t1, t2) +} + +var protoMessageType = reflect.TypeOf((*Message)(nil)).Elem() + +// Initialize the fields for encoding and decoding. +func (p *Properties) setEncAndDec(typ reflect.Type, f *reflect.StructField, lockGetProp bool) { + p.enc = nil + p.dec = nil + p.size = nil + if len(p.CustomType) > 0 { + p.setCustomEncAndDec(typ) + p.setTag(lockGetProp) + return + } + switch t1 := typ; t1.Kind() { + default: + fmt.Fprintf(os.Stderr, "proto: no coders for %v\n", t1) + + // proto3 scalar types + + case reflect.Bool: + if p.proto3 { + p.enc = (*Buffer).enc_proto3_bool + p.dec = (*Buffer).dec_proto3_bool + p.size = size_proto3_bool + } else { + p.enc = (*Buffer).enc_ref_bool + p.dec = (*Buffer).dec_proto3_bool + p.size = size_ref_bool + } + case reflect.Int32: + if p.proto3 { + p.enc = (*Buffer).enc_proto3_int32 + p.dec = (*Buffer).dec_proto3_int32 + p.size = size_proto3_int32 + } else { + p.enc = (*Buffer).enc_ref_int32 + p.dec = (*Buffer).dec_proto3_int32 + p.size = size_ref_int32 + } + case reflect.Uint32: + if p.proto3 { + p.enc = (*Buffer).enc_proto3_uint32 + p.dec = (*Buffer).dec_proto3_int32 // can reuse + p.size = size_proto3_uint32 + } else { + p.enc = (*Buffer).enc_ref_uint32 + p.dec = (*Buffer).dec_proto3_int32 // can reuse + p.size = size_ref_uint32 + } + case reflect.Int64, reflect.Uint64: + if p.proto3 { + p.enc = (*Buffer).enc_proto3_int64 + p.dec = (*Buffer).dec_proto3_int64 + p.size = size_proto3_int64 + } else { + p.enc = (*Buffer).enc_ref_int64 + p.dec = (*Buffer).dec_proto3_int64 + p.size = size_ref_int64 + } + case reflect.Float32: + if p.proto3 { + p.enc = (*Buffer).enc_proto3_uint32 // can just treat them as bits + p.dec = (*Buffer).dec_proto3_int32 + p.size = size_proto3_uint32 + } else { + p.enc = (*Buffer).enc_ref_uint32 // can just treat them as bits + p.dec = (*Buffer).dec_proto3_int32 + p.size = size_ref_uint32 + } + case reflect.Float64: + if p.proto3 { + p.enc = (*Buffer).enc_proto3_int64 // can just treat them as bits + p.dec = (*Buffer).dec_proto3_int64 + p.size = size_proto3_int64 + } else { + p.enc = (*Buffer).enc_ref_int64 // can just treat them as bits + p.dec = (*Buffer).dec_proto3_int64 + p.size = size_ref_int64 + } + case reflect.String: + if p.proto3 { + p.enc = (*Buffer).enc_proto3_string + p.dec = (*Buffer).dec_proto3_string + p.size = size_proto3_string + } else { + p.enc = (*Buffer).enc_ref_string + p.dec = (*Buffer).dec_proto3_string + p.size = size_ref_string + } + case reflect.Struct: + p.stype = typ + p.isMarshaler = isMarshaler(typ) + p.isUnmarshaler = isUnmarshaler(typ) + if p.Wire == "bytes" { + p.enc = (*Buffer).enc_ref_struct_message + p.dec = (*Buffer).dec_ref_struct_message + p.size = size_ref_struct_message + } else { + fmt.Fprintf(os.Stderr, "proto: no coders for struct %T\n", typ) + } + + case reflect.Ptr: + switch t2 := t1.Elem(); t2.Kind() { + default: + fmt.Fprintf(os.Stderr, "proto: no encoder function for %v -> %v\n", t1, t2) + break + case reflect.Bool: + p.enc = (*Buffer).enc_bool + p.dec = (*Buffer).dec_bool + p.size = size_bool + case reflect.Int32: + p.enc = (*Buffer).enc_int32 + p.dec = (*Buffer).dec_int32 + p.size = size_int32 + case reflect.Uint32: + p.enc = (*Buffer).enc_uint32 + p.dec = (*Buffer).dec_int32 // can reuse + p.size = size_uint32 + case reflect.Int64, reflect.Uint64: + p.enc = (*Buffer).enc_int64 + p.dec = (*Buffer).dec_int64 + p.size = size_int64 + case reflect.Float32: + p.enc = (*Buffer).enc_uint32 // can just treat them as bits + p.dec = (*Buffer).dec_int32 + p.size = size_uint32 + case reflect.Float64: + p.enc = (*Buffer).enc_int64 // can just treat them as bits + p.dec = (*Buffer).dec_int64 + p.size = size_int64 + case reflect.String: + p.enc = (*Buffer).enc_string + p.dec = (*Buffer).dec_string + p.size = size_string + case reflect.Struct: + p.stype = t1.Elem() + p.isMarshaler = isMarshaler(t1) + p.isUnmarshaler = isUnmarshaler(t1) + if p.Wire == "bytes" { + p.enc = (*Buffer).enc_struct_message + p.dec = (*Buffer).dec_struct_message + p.size = size_struct_message + } else { + p.enc = (*Buffer).enc_struct_group + p.dec = (*Buffer).dec_struct_group + p.size = size_struct_group + } + } + + case reflect.Slice: + switch t2 := t1.Elem(); t2.Kind() { + default: + logNoSliceEnc(t1, t2) + break + case reflect.Bool: + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_bool + p.size = size_slice_packed_bool + } else { + p.enc = (*Buffer).enc_slice_bool + p.size = size_slice_bool + } + p.dec = (*Buffer).dec_slice_bool + p.packedDec = (*Buffer).dec_slice_packed_bool + case reflect.Int32: + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_int32 + p.size = size_slice_packed_int32 + } else { + p.enc = (*Buffer).enc_slice_int32 + p.size = size_slice_int32 + } + p.dec = (*Buffer).dec_slice_int32 + p.packedDec = (*Buffer).dec_slice_packed_int32 + case reflect.Uint32: + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_uint32 + p.size = size_slice_packed_uint32 + } else { + p.enc = (*Buffer).enc_slice_uint32 + p.size = size_slice_uint32 + } + p.dec = (*Buffer).dec_slice_int32 + p.packedDec = (*Buffer).dec_slice_packed_int32 + case reflect.Int64, reflect.Uint64: + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_int64 + p.size = size_slice_packed_int64 + } else { + p.enc = (*Buffer).enc_slice_int64 + p.size = size_slice_int64 + } + p.dec = (*Buffer).dec_slice_int64 + p.packedDec = (*Buffer).dec_slice_packed_int64 + case reflect.Uint8: + p.enc = (*Buffer).enc_slice_byte + p.dec = (*Buffer).dec_slice_byte + p.size = size_slice_byte + // This is a []byte, which is either a bytes field, + // or the value of a map field. In the latter case, + // we always encode an empty []byte, so we should not + // use the proto3 enc/size funcs. + // f == nil iff this is the key/value of a map field. + if p.proto3 && f != nil { + p.enc = (*Buffer).enc_proto3_slice_byte + p.size = size_proto3_slice_byte + } + case reflect.Float32, reflect.Float64: + switch t2.Bits() { + case 32: + // can just treat them as bits + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_uint32 + p.size = size_slice_packed_uint32 + } else { + p.enc = (*Buffer).enc_slice_uint32 + p.size = size_slice_uint32 + } + p.dec = (*Buffer).dec_slice_int32 + p.packedDec = (*Buffer).dec_slice_packed_int32 + case 64: + // can just treat them as bits + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_int64 + p.size = size_slice_packed_int64 + } else { + p.enc = (*Buffer).enc_slice_int64 + p.size = size_slice_int64 + } + p.dec = (*Buffer).dec_slice_int64 + p.packedDec = (*Buffer).dec_slice_packed_int64 + default: + logNoSliceEnc(t1, t2) + break + } + case reflect.String: + p.enc = (*Buffer).enc_slice_string + p.dec = (*Buffer).dec_slice_string + p.size = size_slice_string + case reflect.Ptr: + switch t3 := t2.Elem(); t3.Kind() { + default: + fmt.Fprintf(os.Stderr, "proto: no ptr oenc for %T -> %T -> %T\n", t1, t2, t3) + break + case reflect.Struct: + p.stype = t2.Elem() + p.isMarshaler = isMarshaler(t2) + p.isUnmarshaler = isUnmarshaler(t2) + if p.Wire == "bytes" { + p.enc = (*Buffer).enc_slice_struct_message + p.dec = (*Buffer).dec_slice_struct_message + p.size = size_slice_struct_message + } else { + p.enc = (*Buffer).enc_slice_struct_group + p.dec = (*Buffer).dec_slice_struct_group + p.size = size_slice_struct_group + } + } + case reflect.Slice: + switch t2.Elem().Kind() { + default: + fmt.Fprintf(os.Stderr, "proto: no slice elem oenc for %T -> %T -> %T\n", t1, t2, t2.Elem()) + break + case reflect.Uint8: + p.enc = (*Buffer).enc_slice_slice_byte + p.dec = (*Buffer).dec_slice_slice_byte + p.size = size_slice_slice_byte + } + case reflect.Struct: + p.setSliceOfNonPointerStructs(t1) + } + + case reflect.Map: + p.enc = (*Buffer).enc_new_map + p.dec = (*Buffer).dec_new_map + p.size = size_new_map + + p.mtype = t1 + p.mkeyprop = &Properties{} + p.mkeyprop.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp) + p.mvalprop = &Properties{} + vtype := p.mtype.Elem() + if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice { + // The value type is not a message (*T) or bytes ([]byte), + // so we need encoders for the pointer to this type. + vtype = reflect.PtrTo(vtype) + } + p.mvalprop.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp) + } + p.setTag(lockGetProp) +} + +func (p *Properties) setTag(lockGetProp bool) { + // precalculate tag code + wire := p.WireType + if p.Packed { + wire = WireBytes + } + x := uint32(p.Tag)<<3 | uint32(wire) + i := 0 + for i = 0; x > 127; i++ { + p.tagbuf[i] = 0x80 | uint8(x&0x7F) + x >>= 7 + } + p.tagbuf[i] = uint8(x) + p.tagcode = p.tagbuf[0 : i+1] + + if p.stype != nil { + if lockGetProp { + p.sprop = GetProperties(p.stype) + } else { + p.sprop = getPropertiesLocked(p.stype) + } + } +} + +var ( + marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem() + unmarshalerType = reflect.TypeOf((*Unmarshaler)(nil)).Elem() +) + +// isMarshaler reports whether type t implements Marshaler. +func isMarshaler(t reflect.Type) bool { + return t.Implements(marshalerType) +} + +// isUnmarshaler reports whether type t implements Unmarshaler. +func isUnmarshaler(t reflect.Type) bool { + return t.Implements(unmarshalerType) +} + +// Init populates the properties from a protocol buffer struct tag. +func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) { + p.init(typ, name, tag, f, true) +} + +func (p *Properties) init(typ reflect.Type, name, tag string, f *reflect.StructField, lockGetProp bool) { + // "bytes,49,opt,def=hello!" + p.Name = name + p.OrigName = name + if f != nil { + p.field = toField(f) + } + if tag == "" { + return + } + p.Parse(tag) + p.setEncAndDec(typ, f, lockGetProp) +} + +var ( + propertiesMu sync.RWMutex + propertiesMap = make(map[reflect.Type]*StructProperties) +) + +// GetProperties returns the list of properties for the type represented by t. +// t must represent a generated struct type of a protocol message. +func GetProperties(t reflect.Type) *StructProperties { + if t.Kind() != reflect.Struct { + panic("proto: type must have kind struct") + } + + // Most calls to GetProperties in a long-running program will be + // retrieving details for types we have seen before. + propertiesMu.RLock() + sprop, ok := propertiesMap[t] + propertiesMu.RUnlock() + if ok { + if collectStats { + stats.Chit++ + } + return sprop + } + + propertiesMu.Lock() + sprop = getPropertiesLocked(t) + propertiesMu.Unlock() + return sprop +} + +// getPropertiesLocked requires that propertiesMu is held. +func getPropertiesLocked(t reflect.Type) *StructProperties { + if prop, ok := propertiesMap[t]; ok { + if collectStats { + stats.Chit++ + } + return prop + } + if collectStats { + stats.Cmiss++ + } + + prop := new(StructProperties) + // in case of recursive protos, fill this in now. + propertiesMap[t] = prop + + // build properties + prop.extendable = reflect.PtrTo(t).Implements(extendableProtoType) + prop.unrecField = invalidField + prop.Prop = make([]*Properties, t.NumField()) + prop.order = make([]int, t.NumField()) + + isOneofMessage := false + for i := 0; i < t.NumField(); i++ { + f := t.Field(i) + p := new(Properties) + name := f.Name + p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false) + + if f.Name == "XXX_extensions" { // special case + if len(f.Tag.Get("protobuf")) > 0 { + p.enc = (*Buffer).enc_ext_slice_byte + p.dec = nil // not needed + p.size = size_ext_slice_byte + } else { + p.enc = (*Buffer).enc_map + p.dec = nil // not needed + p.size = size_map + } + } + if f.Name == "XXX_unrecognized" { // special case + prop.unrecField = toField(&f) + } + oneof := f.Tag.Get("protobuf_oneof") != "" // special case + if oneof { + isOneofMessage = true + } + prop.Prop[i] = p + prop.order[i] = i + if debug { + print(i, " ", f.Name, " ", t.String(), " ") + if p.Tag > 0 { + print(p.String()) + } + print("\n") + } + if p.enc == nil && !strings.HasPrefix(f.Name, "XXX_") && !oneof { + fmt.Fprintln(os.Stderr, "proto: no encoder for", f.Name, f.Type.String(), "[GetProperties]") + } + } + + // Re-order prop.order. + sort.Sort(prop) + + type oneofMessage interface { + XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), []interface{}) + } + if om, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); isOneofMessage && ok { + var oots []interface{} + prop.oneofMarshaler, prop.oneofUnmarshaler, oots = om.XXX_OneofFuncs() + prop.stype = t + + // Interpret oneof metadata. + prop.OneofTypes = make(map[string]*OneofProperties) + for _, oot := range oots { + oop := &OneofProperties{ + Type: reflect.ValueOf(oot).Type(), // *T + Prop: new(Properties), + } + sft := oop.Type.Elem().Field(0) + oop.Prop.Name = sft.Name + oop.Prop.Parse(sft.Tag.Get("protobuf")) + // There will be exactly one interface field that + // this new value is assignable to. + for i := 0; i < t.NumField(); i++ { + f := t.Field(i) + if f.Type.Kind() != reflect.Interface { + continue + } + if !oop.Type.AssignableTo(f.Type) { + continue + } + oop.Field = i + break + } + prop.OneofTypes[oop.Prop.OrigName] = oop + } + } + + // build required counts + // build tags + reqCount := 0 + prop.decoderOrigNames = make(map[string]int) + for i, p := range prop.Prop { + if strings.HasPrefix(p.Name, "XXX_") { + // Internal fields should not appear in tags/origNames maps. + // They are handled specially when encoding and decoding. + continue + } + if p.Required { + reqCount++ + } + prop.decoderTags.put(p.Tag, i) + prop.decoderOrigNames[p.OrigName] = i + } + prop.reqCount = reqCount + + return prop +} + +// Return the Properties object for the x[0]'th field of the structure. +func propByIndex(t reflect.Type, x []int) *Properties { + if len(x) != 1 { + fmt.Fprintf(os.Stderr, "proto: field index dimension %d (not 1) for type %s\n", len(x), t) + return nil + } + prop := GetProperties(t) + return prop.Prop[x[0]] +} + +// Get the address and type of a pointer to a struct from an interface. +func getbase(pb Message) (t reflect.Type, b structPointer, err error) { + if pb == nil { + err = ErrNil + return + } + // get the reflect type of the pointer to the struct. + t = reflect.TypeOf(pb) + // get the address of the struct. + value := reflect.ValueOf(pb) + b = toStructPointer(value) + return +} + +// A global registry of enum types. +// The generated code will register the generated maps by calling RegisterEnum. + +var enumValueMaps = make(map[string]map[string]int32) +var enumStringMaps = make(map[string]map[int32]string) + +// RegisterEnum is called from the generated code to install the enum descriptor +// maps into the global table to aid parsing text format protocol buffers. +func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) { + if _, ok := enumValueMaps[typeName]; ok { + panic("proto: duplicate enum registered: " + typeName) + } + enumValueMaps[typeName] = valueMap + if _, ok := enumStringMaps[typeName]; ok { + panic("proto: duplicate enum registered: " + typeName) + } + enumStringMaps[typeName] = unusedNameMap +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/properties_gogo.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/properties_gogo.go new file mode 100644 index 0000000000000000000000000000000000000000..8daf9f7768c251b3b591f3eff13c778f1f1d65e5 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/properties_gogo.go @@ -0,0 +1,64 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 proto + +import ( + "fmt" + "os" + "reflect" +) + +func (p *Properties) setCustomEncAndDec(typ reflect.Type) { + p.ctype = typ + if p.Repeated { + p.enc = (*Buffer).enc_custom_slice_bytes + p.dec = (*Buffer).dec_custom_slice_bytes + p.size = size_custom_slice_bytes + } else if typ.Kind() == reflect.Ptr { + p.enc = (*Buffer).enc_custom_bytes + p.dec = (*Buffer).dec_custom_bytes + p.size = size_custom_bytes + } else { + p.enc = (*Buffer).enc_custom_ref_bytes + p.dec = (*Buffer).dec_custom_ref_bytes + p.size = size_custom_ref_bytes + } +} + +func (p *Properties) setSliceOfNonPointerStructs(typ reflect.Type) { + t2 := typ.Elem() + p.sstype = typ + p.stype = t2 + p.isMarshaler = isMarshaler(t2) + p.isUnmarshaler = isUnmarshaler(t2) + p.enc = (*Buffer).enc_slice_ref_struct_message + p.dec = (*Buffer).dec_slice_ref_struct_message + p.size = size_slice_ref_struct_message + if p.Wire != "bytes" { + fmt.Fprintf(os.Stderr, "proto: no ptr oenc for %T -> %T \n", typ, t2) + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/proto3_proto/proto3.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/proto3_proto/proto3.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..c23fb08fda38c1f1b90bb3744a47dee6a22c76f1 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/proto3_proto/proto3.pb.go @@ -0,0 +1,126 @@ +// Code generated by protoc-gen-gogo. +// source: proto3_proto/proto3.proto +// DO NOT EDIT! + +/* +Package proto3_proto is a generated protocol buffer package. + +It is generated from these files: + proto3_proto/proto3.proto + +It has these top-level messages: + Message + Nested + MessageWithMap +*/ +package proto3_proto + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" +import testdata "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Message_Humour int32 + +const ( + Message_UNKNOWN Message_Humour = 0 + Message_PUNS Message_Humour = 1 + Message_SLAPSTICK Message_Humour = 2 + Message_BILL_BAILEY Message_Humour = 3 +) + +var Message_Humour_name = map[int32]string{ + 0: "UNKNOWN", + 1: "PUNS", + 2: "SLAPSTICK", + 3: "BILL_BAILEY", +} +var Message_Humour_value = map[string]int32{ + "UNKNOWN": 0, + "PUNS": 1, + "SLAPSTICK": 2, + "BILL_BAILEY": 3, +} + +func (x Message_Humour) String() string { + return proto.EnumName(Message_Humour_name, int32(x)) +} + +type Message struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Hilarity Message_Humour `protobuf:"varint,2,opt,name=hilarity,proto3,enum=proto3_proto.Message_Humour" json:"hilarity,omitempty"` + HeightInCm uint32 `protobuf:"varint,3,opt,name=height_in_cm,proto3" json:"height_in_cm,omitempty"` + Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` + ResultCount int64 `protobuf:"varint,7,opt,name=result_count,proto3" json:"result_count,omitempty"` + TrueScotsman bool `protobuf:"varint,8,opt,name=true_scotsman,proto3" json:"true_scotsman,omitempty"` + Score float32 `protobuf:"fixed32,9,opt,name=score,proto3" json:"score,omitempty"` + Key []uint64 `protobuf:"varint,5,rep,name=key" json:"key,omitempty"` + Nested *Nested `protobuf:"bytes,6,opt,name=nested" json:"nested,omitempty"` + Terrain map[string]*Nested `protobuf:"bytes,10,rep,name=terrain" json:"terrain,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` + Proto2Field *testdata.SubDefaults `protobuf:"bytes,11,opt,name=proto2_field" json:"proto2_field,omitempty"` + Proto2Value map[string]*testdata.SubDefaults `protobuf:"bytes,13,rep,name=proto2_value" json:"proto2_value,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` +} + +func (m *Message) Reset() { *m = Message{} } +func (m *Message) String() string { return proto.CompactTextString(m) } +func (*Message) ProtoMessage() {} + +func (m *Message) GetNested() *Nested { + if m != nil { + return m.Nested + } + return nil +} + +func (m *Message) GetTerrain() map[string]*Nested { + if m != nil { + return m.Terrain + } + return nil +} + +func (m *Message) GetProto2Field() *testdata.SubDefaults { + if m != nil { + return m.Proto2Field + } + return nil +} + +func (m *Message) GetProto2Value() map[string]*testdata.SubDefaults { + if m != nil { + return m.Proto2Value + } + return nil +} + +type Nested struct { + Bunny string `protobuf:"bytes,1,opt,name=bunny,proto3" json:"bunny,omitempty"` +} + +func (m *Nested) Reset() { *m = Nested{} } +func (m *Nested) String() string { return proto.CompactTextString(m) } +func (*Nested) ProtoMessage() {} + +type MessageWithMap struct { + ByteMapping map[bool][]byte `protobuf:"bytes,1,rep,name=byte_mapping" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (m *MessageWithMap) Reset() { *m = MessageWithMap{} } +func (m *MessageWithMap) String() string { return proto.CompactTextString(m) } +func (*MessageWithMap) ProtoMessage() {} + +func (m *MessageWithMap) GetByteMapping() map[bool][]byte { + if m != nil { + return m.ByteMapping + } + return nil +} + +func init() { + proto.RegisterEnum("proto3_proto.Message_Humour", Message_Humour_name, Message_Humour_value) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/proto3_proto/proto3.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/proto3_proto/proto3.proto new file mode 100644 index 0000000000000000000000000000000000000000..ca670015a2636898a3ebddb9e1216c588aeab1c1 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/proto3_proto/proto3.proto @@ -0,0 +1,68 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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 proto3_proto; + +import "github.com/gogo/protobuf/proto/testdata/test.proto"; + +message Message { + enum Humour { + UNKNOWN = 0; + PUNS = 1; + SLAPSTICK = 2; + BILL_BAILEY = 3; + } + + string name = 1; + Humour hilarity = 2; + uint32 height_in_cm = 3; + bytes data = 4; + int64 result_count = 7; + bool true_scotsman = 8; + float score = 9; + + repeated uint64 key = 5; + Nested nested = 6; + + map terrain = 10; + testdata.SubDefaults proto2_field = 11; + map proto2_value = 13; +} + +message Nested { + string bunny = 1; +} + +message MessageWithMap { + map byte_mapping = 1; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/proto3_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/proto3_test.go new file mode 100644 index 0000000000000000000000000000000000000000..3144a375662c93b48fd951f365e73d234a16a048 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/proto3_test.go @@ -0,0 +1,125 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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 proto_test + +import ( + "testing" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + pb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/proto3_proto" + tpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata" +) + +func TestProto3ZeroValues(t *testing.T) { + tests := []struct { + desc string + m proto.Message + }{ + {"zero message", &pb.Message{}}, + {"empty bytes field", &pb.Message{Data: []byte{}}}, + } + for _, test := range tests { + b, err := proto.Marshal(test.m) + if err != nil { + t.Errorf("%s: proto.Marshal: %v", test.desc, err) + continue + } + if len(b) > 0 { + t.Errorf("%s: Encoding is non-empty: %q", test.desc, b) + } + } +} + +func TestRoundTripProto3(t *testing.T) { + m := &pb.Message{ + Name: "David", // (2 | 1<<3): 0x0a 0x05 "David" + Hilarity: pb.Message_PUNS, // (0 | 2<<3): 0x10 0x01 + HeightInCm: 178, // (0 | 3<<3): 0x18 0xb2 0x01 + Data: []byte("roboto"), // (2 | 4<<3): 0x20 0x06 "roboto" + ResultCount: 47, // (0 | 7<<3): 0x38 0x2f + TrueScotsman: true, // (0 | 8<<3): 0x40 0x01 + Score: 8.1, // (5 | 9<<3): 0x4d <8.1> + + Key: []uint64{1, 0xdeadbeef}, + Nested: &pb.Nested{ + Bunny: "Monty", + }, + } + t.Logf(" m: %v", m) + + b, err := proto.Marshal(m) + if err != nil { + t.Fatalf("proto.Marshal: %v", err) + } + t.Logf(" b: %q", b) + + m2 := new(pb.Message) + if err := proto.Unmarshal(b, m2); err != nil { + t.Fatalf("proto.Unmarshal: %v", err) + } + t.Logf("m2: %v", m2) + + if !proto.Equal(m, m2) { + t.Errorf("proto.Equal returned false:\n m: %v\nm2: %v", m, m2) + } +} + +func TestProto3SetDefaults(t *testing.T) { + in := &pb.Message{ + Terrain: map[string]*pb.Nested{ + "meadow": new(pb.Nested), + }, + Proto2Field: new(tpb.SubDefaults), + Proto2Value: map[string]*tpb.SubDefaults{ + "badlands": new(tpb.SubDefaults), + }, + } + + got := proto.Clone(in).(*pb.Message) + proto.SetDefaults(got) + + // There are no defaults in proto3. Everything should be the zero value, but + // we need to remember to set defaults for nested proto2 messages. + want := &pb.Message{ + Terrain: map[string]*pb.Nested{ + "meadow": new(pb.Nested), + }, + Proto2Field: &tpb.SubDefaults{N: proto.Int64(7)}, + Proto2Value: map[string]*tpb.SubDefaults{ + "badlands": {N: proto.Int64(7)}, + }, + } + + if !proto.Equal(got, want) { + t.Errorf("with in = %v\nproto.SetDefaults(in) =>\ngot %v\nwant %v", in, got, want) + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/size2_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/size2_test.go new file mode 100644 index 0000000000000000000000000000000000000000..a2729c39a1b83c3ca2d2958d17de640feba9edf7 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/size2_test.go @@ -0,0 +1,63 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2012 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 proto + +import ( + "testing" +) + +// This is a separate file and package from size_test.go because that one uses +// generated messages and thus may not be in package proto without having a circular +// dependency, whereas this file tests unexported details of size.go. + +func TestVarintSize(t *testing.T) { + // Check the edge cases carefully. + testCases := []struct { + n uint64 + size int + }{ + {0, 1}, + {1, 1}, + {127, 1}, + {128, 2}, + {16383, 2}, + {16384, 3}, + {1<<63 - 1, 9}, + {1 << 63, 10}, + } + for _, tc := range testCases { + size := sizeVarint(tc.n) + if size != tc.size { + t.Errorf("sizeVarint(%d) = %d, want %d", tc.n, size, tc.size) + } + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/size_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/size_test.go new file mode 100644 index 0000000000000000000000000000000000000000..c6eccf1d18de91d473d92f39910287be1f31d5a5 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/size_test.go @@ -0,0 +1,147 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2012 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 proto_test + +import ( + "log" + "strings" + "testing" + + . "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + proto3pb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/proto3_proto" + pb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata" +) + +var messageWithExtension1 = &pb.MyMessage{Count: Int32(7)} + +// messageWithExtension2 is in equal_test.go. +var messageWithExtension3 = &pb.MyMessage{Count: Int32(8)} + +func init() { + if err := SetExtension(messageWithExtension1, pb.E_Ext_More, &pb.Ext{Data: String("Abbott")}); err != nil { + log.Panicf("SetExtension: %v", err) + } + if err := SetExtension(messageWithExtension3, pb.E_Ext_More, &pb.Ext{Data: String("Costello")}); err != nil { + log.Panicf("SetExtension: %v", err) + } + + // Force messageWithExtension3 to have the extension encoded. + Marshal(messageWithExtension3) + +} + +var SizeTests = []struct { + desc string + pb Message +}{ + {"empty", &pb.OtherMessage{}}, + // Basic types. + {"bool", &pb.Defaults{F_Bool: Bool(true)}}, + {"int32", &pb.Defaults{F_Int32: Int32(12)}}, + {"negative int32", &pb.Defaults{F_Int32: Int32(-1)}}, + {"small int64", &pb.Defaults{F_Int64: Int64(1)}}, + {"big int64", &pb.Defaults{F_Int64: Int64(1 << 20)}}, + {"negative int64", &pb.Defaults{F_Int64: Int64(-1)}}, + {"fixed32", &pb.Defaults{F_Fixed32: Uint32(71)}}, + {"fixed64", &pb.Defaults{F_Fixed64: Uint64(72)}}, + {"uint32", &pb.Defaults{F_Uint32: Uint32(123)}}, + {"uint64", &pb.Defaults{F_Uint64: Uint64(124)}}, + {"float", &pb.Defaults{F_Float: Float32(12.6)}}, + {"double", &pb.Defaults{F_Double: Float64(13.9)}}, + {"string", &pb.Defaults{F_String: String("niles")}}, + {"bytes", &pb.Defaults{F_Bytes: []byte("wowsa")}}, + {"bytes, empty", &pb.Defaults{F_Bytes: []byte{}}}, + {"sint32", &pb.Defaults{F_Sint32: Int32(65)}}, + {"sint64", &pb.Defaults{F_Sint64: Int64(67)}}, + {"enum", &pb.Defaults{F_Enum: pb.Defaults_BLUE.Enum()}}, + // Repeated. + {"empty repeated bool", &pb.MoreRepeated{Bools: []bool{}}}, + {"repeated bool", &pb.MoreRepeated{Bools: []bool{false, true, true, false}}}, + {"packed repeated bool", &pb.MoreRepeated{BoolsPacked: []bool{false, true, true, false, true, true, true}}}, + {"repeated int32", &pb.MoreRepeated{Ints: []int32{1, 12203, 1729, -1}}}, + {"repeated int32 packed", &pb.MoreRepeated{IntsPacked: []int32{1, 12203, 1729}}}, + {"repeated int64 packed", &pb.MoreRepeated{Int64SPacked: []int64{ + // Need enough large numbers to verify that the header is counting the number of bytes + // for the field, not the number of elements. + 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, + 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, 1 << 62, + }}}, + {"repeated string", &pb.MoreRepeated{Strings: []string{"r", "ken", "gri"}}}, + {"repeated fixed", &pb.MoreRepeated{Fixeds: []uint32{1, 2, 3, 4}}}, + // Nested. + {"nested", &pb.OldMessage{Nested: &pb.OldMessage_Nested{Name: String("whatever")}}}, + {"group", &pb.GroupOld{G: &pb.GroupOld_G{X: Int32(12345)}}}, + // Other things. + {"unrecognized", &pb.MoreRepeated{XXX_unrecognized: []byte{13<<3 | 0, 4}}}, + {"extension (unencoded)", messageWithExtension1}, + {"extension (encoded)", messageWithExtension3}, + // proto3 message + {"proto3 empty", &proto3pb.Message{}}, + {"proto3 bool", &proto3pb.Message{TrueScotsman: true}}, + {"proto3 int64", &proto3pb.Message{ResultCount: 1}}, + {"proto3 uint32", &proto3pb.Message{HeightInCm: 123}}, + {"proto3 float", &proto3pb.Message{Score: 12.6}}, + {"proto3 string", &proto3pb.Message{Name: "Snezana"}}, + {"proto3 bytes", &proto3pb.Message{Data: []byte("wowsa")}}, + {"proto3 bytes, empty", &proto3pb.Message{Data: []byte{}}}, + {"proto3 enum", &proto3pb.Message{Hilarity: proto3pb.Message_PUNS}}, + {"proto3 map field with empty bytes", &proto3pb.MessageWithMap{ByteMapping: map[bool][]byte{false: {}}}}, + + {"map field", &pb.MessageWithMap{NameMapping: map[int32]string{1: "Rob", 7: "Andrew"}}}, + {"map field with message", &pb.MessageWithMap{MsgMapping: map[int64]*pb.FloatingPoint{0x7001: {F: Float64(2.0)}}}}, + {"map field with bytes", &pb.MessageWithMap{ByteMapping: map[bool][]byte{true: []byte("this time for sure")}}}, + {"map field with empty bytes", &pb.MessageWithMap{ByteMapping: map[bool][]byte{true: {}}}}, + + {"map field with big entry", &pb.MessageWithMap{NameMapping: map[int32]string{8: strings.Repeat("x", 125)}}}, + {"map field with big key and val", &pb.MessageWithMap{StrToStr: map[string]string{strings.Repeat("x", 70): strings.Repeat("y", 70)}}}, + {"map field with big numeric key", &pb.MessageWithMap{NameMapping: map[int32]string{0xf00d: "om nom nom"}}}, + + {"oneof not set", &pb.Communique{}}, + {"oneof zero int32", &pb.Communique{Union: &pb.Communique_Number{Number: 0}}}, + {"oneof int32", &pb.Communique{Union: &pb.Communique_Number{Number: 3}}}, + {"oneof string", &pb.Communique{Union: &pb.Communique_Name{Name: "Rhythmic Fman"}}}, +} + +func TestSize(t *testing.T) { + for _, tc := range SizeTests { + size := Size(tc.pb) + b, err := Marshal(tc.pb) + if err != nil { + t.Errorf("%v: Marshal failed: %v", tc.desc, err) + continue + } + if size != len(b) { + t.Errorf("%v: Size(%v) = %d, want %d", tc.desc, tc.pb, size, len(b)) + t.Logf("%v: bytes: %#v", tc.desc, b) + } + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/skip_gogo.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/skip_gogo.go new file mode 100644 index 0000000000000000000000000000000000000000..4fe7e0815c9f3e4de9e31df2311fea513a0db605 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/skip_gogo.go @@ -0,0 +1,117 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 proto + +import ( + "fmt" + "io" +) + +func Skip(data []byte) (n int, err error) { + l := len(data) + index := 0 + for index < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if index >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[index] + index++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for { + if index >= l { + return 0, io.ErrUnexpectedEOF + } + index++ + if data[index-1] < 0x80 { + break + } + } + return index, nil + case 1: + index += 8 + return index, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if index >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[index] + index++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + index += length + return index, nil + case 3: + for { + var innerWire uint64 + var start int = index + for shift := uint(0); ; shift += 7 { + if index >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[index] + index++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := Skip(data[start:]) + if err != nil { + return 0, err + } + index = start + next + } + return index, nil + case 4: + return index, nil + case 5: + index += 4 + return index, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..31d83277ccf15eb395fef98735ea879b693e1fb7 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata/Makefile @@ -0,0 +1,37 @@ +# Go support for Protocol Buffers - Google's data interchange format +# +# Copyright 2010 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. + +all: regenerate + +regenerate: + go install github.com/gogo/protobuf/protoc-min-version + protoc-min-version --version="3.0.0" --gogo_out=. test.proto + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata/golden_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata/golden_test.go new file mode 100644 index 0000000000000000000000000000000000000000..8e84515377a966e406287d395628b0dfd52e2acf --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata/golden_test.go @@ -0,0 +1,86 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2012 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. + +// Verify that the compiler output for test.proto is unchanged. + +package testdata + +import ( + "crypto/sha1" + "fmt" + "io/ioutil" + "os" + "os/exec" + "path/filepath" + "testing" +) + +// sum returns in string form (for easy comparison) the SHA-1 hash of the named file. +func sum(t *testing.T, name string) string { + data, err := ioutil.ReadFile(name) + if err != nil { + t.Fatal(err) + } + t.Logf("sum(%q): length is %d", name, len(data)) + hash := sha1.New() + _, err = hash.Write(data) + if err != nil { + t.Fatal(err) + } + return fmt.Sprintf("% x", hash.Sum(nil)) +} + +func run(t *testing.T, name string, args ...string) { + cmd := exec.Command(name, args...) + cmd.Stdin = os.Stdin + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + err := cmd.Run() + if err != nil { + t.Fatal(err) + } +} + +func TestGolden(t *testing.T) { + // Compute the original checksum. + goldenSum := sum(t, "test.pb.go") + // Run the proto compiler. + run(t, "protoc", "--gogo_out="+os.TempDir(), "test.proto") + newFile := filepath.Join(os.TempDir(), "test.pb.go") + defer os.Remove(newFile) + // Compute the new checksum. + newSum := sum(t, newFile) + // Verify + if newSum != goldenSum { + run(t, "diff", "-u", "test.pb.go", newFile) + t.Fatal("Code generated by protoc-gen-go has changed; update test.pb.go") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata/test.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata/test.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..d732e560ee4c9ccd3d386e51f8e99668de1b9d6a --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata/test.pb.go @@ -0,0 +1,2948 @@ +// Code generated by protoc-gen-gogo. +// source: test.proto +// DO NOT EDIT! + +/* +Package testdata is a generated protocol buffer package. + +It is generated from these files: + test.proto + +It has these top-level messages: + GoEnum + GoTestField + GoTest + GoSkipTest + NonPackedTest + PackedTest + MaxTag + OldMessage + NewMessage + InnerMessage + OtherMessage + MyMessage + Ext + DefaultsMessage + MyMessageSet + Empty + MessageList + Strings + Defaults + SubDefaults + RepeatedEnum + MoreRepeated + GroupOld + GroupNew + FloatingPoint + MessageWithMap + Communique +*/ +package testdata + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type FOO int32 + +const ( + FOO_FOO1 FOO = 1 +) + +var FOO_name = map[int32]string{ + 1: "FOO1", +} +var FOO_value = map[string]int32{ + "FOO1": 1, +} + +func (x FOO) Enum() *FOO { + p := new(FOO) + *p = x + return p +} +func (x FOO) String() string { + return proto.EnumName(FOO_name, int32(x)) +} +func (x *FOO) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FOO_value, data, "FOO") + if err != nil { + return err + } + *x = FOO(value) + return nil +} + +// An enum, for completeness. +type GoTest_KIND int32 + +const ( + GoTest_VOID GoTest_KIND = 0 + // Basic types + GoTest_BOOL GoTest_KIND = 1 + GoTest_BYTES GoTest_KIND = 2 + GoTest_FINGERPRINT GoTest_KIND = 3 + GoTest_FLOAT GoTest_KIND = 4 + GoTest_INT GoTest_KIND = 5 + GoTest_STRING GoTest_KIND = 6 + GoTest_TIME GoTest_KIND = 7 + // Groupings + GoTest_TUPLE GoTest_KIND = 8 + GoTest_ARRAY GoTest_KIND = 9 + GoTest_MAP GoTest_KIND = 10 + // Table types + GoTest_TABLE GoTest_KIND = 11 + // Functions + GoTest_FUNCTION GoTest_KIND = 12 +) + +var GoTest_KIND_name = map[int32]string{ + 0: "VOID", + 1: "BOOL", + 2: "BYTES", + 3: "FINGERPRINT", + 4: "FLOAT", + 5: "INT", + 6: "STRING", + 7: "TIME", + 8: "TUPLE", + 9: "ARRAY", + 10: "MAP", + 11: "TABLE", + 12: "FUNCTION", +} +var GoTest_KIND_value = map[string]int32{ + "VOID": 0, + "BOOL": 1, + "BYTES": 2, + "FINGERPRINT": 3, + "FLOAT": 4, + "INT": 5, + "STRING": 6, + "TIME": 7, + "TUPLE": 8, + "ARRAY": 9, + "MAP": 10, + "TABLE": 11, + "FUNCTION": 12, +} + +func (x GoTest_KIND) Enum() *GoTest_KIND { + p := new(GoTest_KIND) + *p = x + return p +} +func (x GoTest_KIND) String() string { + return proto.EnumName(GoTest_KIND_name, int32(x)) +} +func (x *GoTest_KIND) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(GoTest_KIND_value, data, "GoTest_KIND") + if err != nil { + return err + } + *x = GoTest_KIND(value) + return nil +} + +type MyMessage_Color int32 + +const ( + MyMessage_RED MyMessage_Color = 0 + MyMessage_GREEN MyMessage_Color = 1 + MyMessage_BLUE MyMessage_Color = 2 +) + +var MyMessage_Color_name = map[int32]string{ + 0: "RED", + 1: "GREEN", + 2: "BLUE", +} +var MyMessage_Color_value = map[string]int32{ + "RED": 0, + "GREEN": 1, + "BLUE": 2, +} + +func (x MyMessage_Color) Enum() *MyMessage_Color { + p := new(MyMessage_Color) + *p = x + return p +} +func (x MyMessage_Color) String() string { + return proto.EnumName(MyMessage_Color_name, int32(x)) +} +func (x *MyMessage_Color) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(MyMessage_Color_value, data, "MyMessage_Color") + if err != nil { + return err + } + *x = MyMessage_Color(value) + return nil +} + +type DefaultsMessage_DefaultsEnum int32 + +const ( + DefaultsMessage_ZERO DefaultsMessage_DefaultsEnum = 0 + DefaultsMessage_ONE DefaultsMessage_DefaultsEnum = 1 + DefaultsMessage_TWO DefaultsMessage_DefaultsEnum = 2 +) + +var DefaultsMessage_DefaultsEnum_name = map[int32]string{ + 0: "ZERO", + 1: "ONE", + 2: "TWO", +} +var DefaultsMessage_DefaultsEnum_value = map[string]int32{ + "ZERO": 0, + "ONE": 1, + "TWO": 2, +} + +func (x DefaultsMessage_DefaultsEnum) Enum() *DefaultsMessage_DefaultsEnum { + p := new(DefaultsMessage_DefaultsEnum) + *p = x + return p +} +func (x DefaultsMessage_DefaultsEnum) String() string { + return proto.EnumName(DefaultsMessage_DefaultsEnum_name, int32(x)) +} +func (x *DefaultsMessage_DefaultsEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DefaultsMessage_DefaultsEnum_value, data, "DefaultsMessage_DefaultsEnum") + if err != nil { + return err + } + *x = DefaultsMessage_DefaultsEnum(value) + return nil +} + +type Defaults_Color int32 + +const ( + Defaults_RED Defaults_Color = 0 + Defaults_GREEN Defaults_Color = 1 + Defaults_BLUE Defaults_Color = 2 +) + +var Defaults_Color_name = map[int32]string{ + 0: "RED", + 1: "GREEN", + 2: "BLUE", +} +var Defaults_Color_value = map[string]int32{ + "RED": 0, + "GREEN": 1, + "BLUE": 2, +} + +func (x Defaults_Color) Enum() *Defaults_Color { + p := new(Defaults_Color) + *p = x + return p +} +func (x Defaults_Color) String() string { + return proto.EnumName(Defaults_Color_name, int32(x)) +} +func (x *Defaults_Color) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Defaults_Color_value, data, "Defaults_Color") + if err != nil { + return err + } + *x = Defaults_Color(value) + return nil +} + +type RepeatedEnum_Color int32 + +const ( + RepeatedEnum_RED RepeatedEnum_Color = 1 +) + +var RepeatedEnum_Color_name = map[int32]string{ + 1: "RED", +} +var RepeatedEnum_Color_value = map[string]int32{ + "RED": 1, +} + +func (x RepeatedEnum_Color) Enum() *RepeatedEnum_Color { + p := new(RepeatedEnum_Color) + *p = x + return p +} +func (x RepeatedEnum_Color) String() string { + return proto.EnumName(RepeatedEnum_Color_name, int32(x)) +} +func (x *RepeatedEnum_Color) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(RepeatedEnum_Color_value, data, "RepeatedEnum_Color") + if err != nil { + return err + } + *x = RepeatedEnum_Color(value) + return nil +} + +type GoEnum struct { + Foo *FOO `protobuf:"varint,1,req,name=foo,enum=testdata.FOO" json:"foo,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GoEnum) Reset() { *m = GoEnum{} } +func (m *GoEnum) String() string { return proto.CompactTextString(m) } +func (*GoEnum) ProtoMessage() {} + +func (m *GoEnum) GetFoo() FOO { + if m != nil && m.Foo != nil { + return *m.Foo + } + return FOO_FOO1 +} + +type GoTestField struct { + Label *string `protobuf:"bytes,1,req,name=Label" json:"Label,omitempty"` + Type *string `protobuf:"bytes,2,req,name=Type" json:"Type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GoTestField) Reset() { *m = GoTestField{} } +func (m *GoTestField) String() string { return proto.CompactTextString(m) } +func (*GoTestField) ProtoMessage() {} + +func (m *GoTestField) GetLabel() string { + if m != nil && m.Label != nil { + return *m.Label + } + return "" +} + +func (m *GoTestField) GetType() string { + if m != nil && m.Type != nil { + return *m.Type + } + return "" +} + +type GoTest struct { + // Some typical parameters + Kind *GoTest_KIND `protobuf:"varint,1,req,name=Kind,enum=testdata.GoTest_KIND" json:"Kind,omitempty"` + Table *string `protobuf:"bytes,2,opt,name=Table" json:"Table,omitempty"` + Param *int32 `protobuf:"varint,3,opt,name=Param" json:"Param,omitempty"` + // Required, repeated and optional foreign fields. + RequiredField *GoTestField `protobuf:"bytes,4,req,name=RequiredField" json:"RequiredField,omitempty"` + RepeatedField []*GoTestField `protobuf:"bytes,5,rep,name=RepeatedField" json:"RepeatedField,omitempty"` + OptionalField *GoTestField `protobuf:"bytes,6,opt,name=OptionalField" json:"OptionalField,omitempty"` + // Required fields of all basic types + F_BoolRequired *bool `protobuf:"varint,10,req,name=F_Bool_required" json:"F_Bool_required,omitempty"` + F_Int32Required *int32 `protobuf:"varint,11,req,name=F_Int32_required" json:"F_Int32_required,omitempty"` + F_Int64Required *int64 `protobuf:"varint,12,req,name=F_Int64_required" json:"F_Int64_required,omitempty"` + F_Fixed32Required *uint32 `protobuf:"fixed32,13,req,name=F_Fixed32_required" json:"F_Fixed32_required,omitempty"` + F_Fixed64Required *uint64 `protobuf:"fixed64,14,req,name=F_Fixed64_required" json:"F_Fixed64_required,omitempty"` + F_Uint32Required *uint32 `protobuf:"varint,15,req,name=F_Uint32_required" json:"F_Uint32_required,omitempty"` + F_Uint64Required *uint64 `protobuf:"varint,16,req,name=F_Uint64_required" json:"F_Uint64_required,omitempty"` + F_FloatRequired *float32 `protobuf:"fixed32,17,req,name=F_Float_required" json:"F_Float_required,omitempty"` + F_DoubleRequired *float64 `protobuf:"fixed64,18,req,name=F_Double_required" json:"F_Double_required,omitempty"` + F_StringRequired *string `protobuf:"bytes,19,req,name=F_String_required" json:"F_String_required,omitempty"` + F_BytesRequired []byte `protobuf:"bytes,101,req,name=F_Bytes_required" json:"F_Bytes_required,omitempty"` + F_Sint32Required *int32 `protobuf:"zigzag32,102,req,name=F_Sint32_required" json:"F_Sint32_required,omitempty"` + F_Sint64Required *int64 `protobuf:"zigzag64,103,req,name=F_Sint64_required" json:"F_Sint64_required,omitempty"` + // Repeated fields of all basic types + F_BoolRepeated []bool `protobuf:"varint,20,rep,name=F_Bool_repeated" json:"F_Bool_repeated,omitempty"` + F_Int32Repeated []int32 `protobuf:"varint,21,rep,name=F_Int32_repeated" json:"F_Int32_repeated,omitempty"` + F_Int64Repeated []int64 `protobuf:"varint,22,rep,name=F_Int64_repeated" json:"F_Int64_repeated,omitempty"` + F_Fixed32Repeated []uint32 `protobuf:"fixed32,23,rep,name=F_Fixed32_repeated" json:"F_Fixed32_repeated,omitempty"` + F_Fixed64Repeated []uint64 `protobuf:"fixed64,24,rep,name=F_Fixed64_repeated" json:"F_Fixed64_repeated,omitempty"` + F_Uint32Repeated []uint32 `protobuf:"varint,25,rep,name=F_Uint32_repeated" json:"F_Uint32_repeated,omitempty"` + F_Uint64Repeated []uint64 `protobuf:"varint,26,rep,name=F_Uint64_repeated" json:"F_Uint64_repeated,omitempty"` + F_FloatRepeated []float32 `protobuf:"fixed32,27,rep,name=F_Float_repeated" json:"F_Float_repeated,omitempty"` + F_DoubleRepeated []float64 `protobuf:"fixed64,28,rep,name=F_Double_repeated" json:"F_Double_repeated,omitempty"` + F_StringRepeated []string `protobuf:"bytes,29,rep,name=F_String_repeated" json:"F_String_repeated,omitempty"` + F_BytesRepeated [][]byte `protobuf:"bytes,201,rep,name=F_Bytes_repeated" json:"F_Bytes_repeated,omitempty"` + F_Sint32Repeated []int32 `protobuf:"zigzag32,202,rep,name=F_Sint32_repeated" json:"F_Sint32_repeated,omitempty"` + F_Sint64Repeated []int64 `protobuf:"zigzag64,203,rep,name=F_Sint64_repeated" json:"F_Sint64_repeated,omitempty"` + // Optional fields of all basic types + F_BoolOptional *bool `protobuf:"varint,30,opt,name=F_Bool_optional" json:"F_Bool_optional,omitempty"` + F_Int32Optional *int32 `protobuf:"varint,31,opt,name=F_Int32_optional" json:"F_Int32_optional,omitempty"` + F_Int64Optional *int64 `protobuf:"varint,32,opt,name=F_Int64_optional" json:"F_Int64_optional,omitempty"` + F_Fixed32Optional *uint32 `protobuf:"fixed32,33,opt,name=F_Fixed32_optional" json:"F_Fixed32_optional,omitempty"` + F_Fixed64Optional *uint64 `protobuf:"fixed64,34,opt,name=F_Fixed64_optional" json:"F_Fixed64_optional,omitempty"` + F_Uint32Optional *uint32 `protobuf:"varint,35,opt,name=F_Uint32_optional" json:"F_Uint32_optional,omitempty"` + F_Uint64Optional *uint64 `protobuf:"varint,36,opt,name=F_Uint64_optional" json:"F_Uint64_optional,omitempty"` + F_FloatOptional *float32 `protobuf:"fixed32,37,opt,name=F_Float_optional" json:"F_Float_optional,omitempty"` + F_DoubleOptional *float64 `protobuf:"fixed64,38,opt,name=F_Double_optional" json:"F_Double_optional,omitempty"` + F_StringOptional *string `protobuf:"bytes,39,opt,name=F_String_optional" json:"F_String_optional,omitempty"` + F_BytesOptional []byte `protobuf:"bytes,301,opt,name=F_Bytes_optional" json:"F_Bytes_optional,omitempty"` + F_Sint32Optional *int32 `protobuf:"zigzag32,302,opt,name=F_Sint32_optional" json:"F_Sint32_optional,omitempty"` + F_Sint64Optional *int64 `protobuf:"zigzag64,303,opt,name=F_Sint64_optional" json:"F_Sint64_optional,omitempty"` + // Default-valued fields of all basic types + F_BoolDefaulted *bool `protobuf:"varint,40,opt,name=F_Bool_defaulted,def=1" json:"F_Bool_defaulted,omitempty"` + F_Int32Defaulted *int32 `protobuf:"varint,41,opt,name=F_Int32_defaulted,def=32" json:"F_Int32_defaulted,omitempty"` + F_Int64Defaulted *int64 `protobuf:"varint,42,opt,name=F_Int64_defaulted,def=64" json:"F_Int64_defaulted,omitempty"` + F_Fixed32Defaulted *uint32 `protobuf:"fixed32,43,opt,name=F_Fixed32_defaulted,def=320" json:"F_Fixed32_defaulted,omitempty"` + F_Fixed64Defaulted *uint64 `protobuf:"fixed64,44,opt,name=F_Fixed64_defaulted,def=640" json:"F_Fixed64_defaulted,omitempty"` + F_Uint32Defaulted *uint32 `protobuf:"varint,45,opt,name=F_Uint32_defaulted,def=3200" json:"F_Uint32_defaulted,omitempty"` + F_Uint64Defaulted *uint64 `protobuf:"varint,46,opt,name=F_Uint64_defaulted,def=6400" json:"F_Uint64_defaulted,omitempty"` + F_FloatDefaulted *float32 `protobuf:"fixed32,47,opt,name=F_Float_defaulted,def=314159" json:"F_Float_defaulted,omitempty"` + F_DoubleDefaulted *float64 `protobuf:"fixed64,48,opt,name=F_Double_defaulted,def=271828" json:"F_Double_defaulted,omitempty"` + F_StringDefaulted *string `protobuf:"bytes,49,opt,name=F_String_defaulted,def=hello, \"world!\"\n" json:"F_String_defaulted,omitempty"` + F_BytesDefaulted []byte `protobuf:"bytes,401,opt,name=F_Bytes_defaulted,def=Bignose" json:"F_Bytes_defaulted,omitempty"` + F_Sint32Defaulted *int32 `protobuf:"zigzag32,402,opt,name=F_Sint32_defaulted,def=-32" json:"F_Sint32_defaulted,omitempty"` + F_Sint64Defaulted *int64 `protobuf:"zigzag64,403,opt,name=F_Sint64_defaulted,def=-64" json:"F_Sint64_defaulted,omitempty"` + // Packed repeated fields (no string or bytes). + F_BoolRepeatedPacked []bool `protobuf:"varint,50,rep,packed,name=F_Bool_repeated_packed" json:"F_Bool_repeated_packed,omitempty"` + F_Int32RepeatedPacked []int32 `protobuf:"varint,51,rep,packed,name=F_Int32_repeated_packed" json:"F_Int32_repeated_packed,omitempty"` + F_Int64RepeatedPacked []int64 `protobuf:"varint,52,rep,packed,name=F_Int64_repeated_packed" json:"F_Int64_repeated_packed,omitempty"` + F_Fixed32RepeatedPacked []uint32 `protobuf:"fixed32,53,rep,packed,name=F_Fixed32_repeated_packed" json:"F_Fixed32_repeated_packed,omitempty"` + F_Fixed64RepeatedPacked []uint64 `protobuf:"fixed64,54,rep,packed,name=F_Fixed64_repeated_packed" json:"F_Fixed64_repeated_packed,omitempty"` + F_Uint32RepeatedPacked []uint32 `protobuf:"varint,55,rep,packed,name=F_Uint32_repeated_packed" json:"F_Uint32_repeated_packed,omitempty"` + F_Uint64RepeatedPacked []uint64 `protobuf:"varint,56,rep,packed,name=F_Uint64_repeated_packed" json:"F_Uint64_repeated_packed,omitempty"` + F_FloatRepeatedPacked []float32 `protobuf:"fixed32,57,rep,packed,name=F_Float_repeated_packed" json:"F_Float_repeated_packed,omitempty"` + F_DoubleRepeatedPacked []float64 `protobuf:"fixed64,58,rep,packed,name=F_Double_repeated_packed" json:"F_Double_repeated_packed,omitempty"` + F_Sint32RepeatedPacked []int32 `protobuf:"zigzag32,502,rep,packed,name=F_Sint32_repeated_packed" json:"F_Sint32_repeated_packed,omitempty"` + F_Sint64RepeatedPacked []int64 `protobuf:"zigzag64,503,rep,packed,name=F_Sint64_repeated_packed" json:"F_Sint64_repeated_packed,omitempty"` + Requiredgroup *GoTest_RequiredGroup `protobuf:"group,70,req,name=RequiredGroup" json:"requiredgroup,omitempty"` + Repeatedgroup []*GoTest_RepeatedGroup `protobuf:"group,80,rep,name=RepeatedGroup" json:"repeatedgroup,omitempty"` + Optionalgroup *GoTest_OptionalGroup `protobuf:"group,90,opt,name=OptionalGroup" json:"optionalgroup,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GoTest) Reset() { *m = GoTest{} } +func (m *GoTest) String() string { return proto.CompactTextString(m) } +func (*GoTest) ProtoMessage() {} + +const Default_GoTest_F_BoolDefaulted bool = true +const Default_GoTest_F_Int32Defaulted int32 = 32 +const Default_GoTest_F_Int64Defaulted int64 = 64 +const Default_GoTest_F_Fixed32Defaulted uint32 = 320 +const Default_GoTest_F_Fixed64Defaulted uint64 = 640 +const Default_GoTest_F_Uint32Defaulted uint32 = 3200 +const Default_GoTest_F_Uint64Defaulted uint64 = 6400 +const Default_GoTest_F_FloatDefaulted float32 = 314159 +const Default_GoTest_F_DoubleDefaulted float64 = 271828 +const Default_GoTest_F_StringDefaulted string = "hello, \"world!\"\n" + +var Default_GoTest_F_BytesDefaulted []byte = []byte("Bignose") + +const Default_GoTest_F_Sint32Defaulted int32 = -32 +const Default_GoTest_F_Sint64Defaulted int64 = -64 + +func (m *GoTest) GetKind() GoTest_KIND { + if m != nil && m.Kind != nil { + return *m.Kind + } + return GoTest_VOID +} + +func (m *GoTest) GetTable() string { + if m != nil && m.Table != nil { + return *m.Table + } + return "" +} + +func (m *GoTest) GetParam() int32 { + if m != nil && m.Param != nil { + return *m.Param + } + return 0 +} + +func (m *GoTest) GetRequiredField() *GoTestField { + if m != nil { + return m.RequiredField + } + return nil +} + +func (m *GoTest) GetRepeatedField() []*GoTestField { + if m != nil { + return m.RepeatedField + } + return nil +} + +func (m *GoTest) GetOptionalField() *GoTestField { + if m != nil { + return m.OptionalField + } + return nil +} + +func (m *GoTest) GetF_BoolRequired() bool { + if m != nil && m.F_BoolRequired != nil { + return *m.F_BoolRequired + } + return false +} + +func (m *GoTest) GetF_Int32Required() int32 { + if m != nil && m.F_Int32Required != nil { + return *m.F_Int32Required + } + return 0 +} + +func (m *GoTest) GetF_Int64Required() int64 { + if m != nil && m.F_Int64Required != nil { + return *m.F_Int64Required + } + return 0 +} + +func (m *GoTest) GetF_Fixed32Required() uint32 { + if m != nil && m.F_Fixed32Required != nil { + return *m.F_Fixed32Required + } + return 0 +} + +func (m *GoTest) GetF_Fixed64Required() uint64 { + if m != nil && m.F_Fixed64Required != nil { + return *m.F_Fixed64Required + } + return 0 +} + +func (m *GoTest) GetF_Uint32Required() uint32 { + if m != nil && m.F_Uint32Required != nil { + return *m.F_Uint32Required + } + return 0 +} + +func (m *GoTest) GetF_Uint64Required() uint64 { + if m != nil && m.F_Uint64Required != nil { + return *m.F_Uint64Required + } + return 0 +} + +func (m *GoTest) GetF_FloatRequired() float32 { + if m != nil && m.F_FloatRequired != nil { + return *m.F_FloatRequired + } + return 0 +} + +func (m *GoTest) GetF_DoubleRequired() float64 { + if m != nil && m.F_DoubleRequired != nil { + return *m.F_DoubleRequired + } + return 0 +} + +func (m *GoTest) GetF_StringRequired() string { + if m != nil && m.F_StringRequired != nil { + return *m.F_StringRequired + } + return "" +} + +func (m *GoTest) GetF_BytesRequired() []byte { + if m != nil { + return m.F_BytesRequired + } + return nil +} + +func (m *GoTest) GetF_Sint32Required() int32 { + if m != nil && m.F_Sint32Required != nil { + return *m.F_Sint32Required + } + return 0 +} + +func (m *GoTest) GetF_Sint64Required() int64 { + if m != nil && m.F_Sint64Required != nil { + return *m.F_Sint64Required + } + return 0 +} + +func (m *GoTest) GetF_BoolRepeated() []bool { + if m != nil { + return m.F_BoolRepeated + } + return nil +} + +func (m *GoTest) GetF_Int32Repeated() []int32 { + if m != nil { + return m.F_Int32Repeated + } + return nil +} + +func (m *GoTest) GetF_Int64Repeated() []int64 { + if m != nil { + return m.F_Int64Repeated + } + return nil +} + +func (m *GoTest) GetF_Fixed32Repeated() []uint32 { + if m != nil { + return m.F_Fixed32Repeated + } + return nil +} + +func (m *GoTest) GetF_Fixed64Repeated() []uint64 { + if m != nil { + return m.F_Fixed64Repeated + } + return nil +} + +func (m *GoTest) GetF_Uint32Repeated() []uint32 { + if m != nil { + return m.F_Uint32Repeated + } + return nil +} + +func (m *GoTest) GetF_Uint64Repeated() []uint64 { + if m != nil { + return m.F_Uint64Repeated + } + return nil +} + +func (m *GoTest) GetF_FloatRepeated() []float32 { + if m != nil { + return m.F_FloatRepeated + } + return nil +} + +func (m *GoTest) GetF_DoubleRepeated() []float64 { + if m != nil { + return m.F_DoubleRepeated + } + return nil +} + +func (m *GoTest) GetF_StringRepeated() []string { + if m != nil { + return m.F_StringRepeated + } + return nil +} + +func (m *GoTest) GetF_BytesRepeated() [][]byte { + if m != nil { + return m.F_BytesRepeated + } + return nil +} + +func (m *GoTest) GetF_Sint32Repeated() []int32 { + if m != nil { + return m.F_Sint32Repeated + } + return nil +} + +func (m *GoTest) GetF_Sint64Repeated() []int64 { + if m != nil { + return m.F_Sint64Repeated + } + return nil +} + +func (m *GoTest) GetF_BoolOptional() bool { + if m != nil && m.F_BoolOptional != nil { + return *m.F_BoolOptional + } + return false +} + +func (m *GoTest) GetF_Int32Optional() int32 { + if m != nil && m.F_Int32Optional != nil { + return *m.F_Int32Optional + } + return 0 +} + +func (m *GoTest) GetF_Int64Optional() int64 { + if m != nil && m.F_Int64Optional != nil { + return *m.F_Int64Optional + } + return 0 +} + +func (m *GoTest) GetF_Fixed32Optional() uint32 { + if m != nil && m.F_Fixed32Optional != nil { + return *m.F_Fixed32Optional + } + return 0 +} + +func (m *GoTest) GetF_Fixed64Optional() uint64 { + if m != nil && m.F_Fixed64Optional != nil { + return *m.F_Fixed64Optional + } + return 0 +} + +func (m *GoTest) GetF_Uint32Optional() uint32 { + if m != nil && m.F_Uint32Optional != nil { + return *m.F_Uint32Optional + } + return 0 +} + +func (m *GoTest) GetF_Uint64Optional() uint64 { + if m != nil && m.F_Uint64Optional != nil { + return *m.F_Uint64Optional + } + return 0 +} + +func (m *GoTest) GetF_FloatOptional() float32 { + if m != nil && m.F_FloatOptional != nil { + return *m.F_FloatOptional + } + return 0 +} + +func (m *GoTest) GetF_DoubleOptional() float64 { + if m != nil && m.F_DoubleOptional != nil { + return *m.F_DoubleOptional + } + return 0 +} + +func (m *GoTest) GetF_StringOptional() string { + if m != nil && m.F_StringOptional != nil { + return *m.F_StringOptional + } + return "" +} + +func (m *GoTest) GetF_BytesOptional() []byte { + if m != nil { + return m.F_BytesOptional + } + return nil +} + +func (m *GoTest) GetF_Sint32Optional() int32 { + if m != nil && m.F_Sint32Optional != nil { + return *m.F_Sint32Optional + } + return 0 +} + +func (m *GoTest) GetF_Sint64Optional() int64 { + if m != nil && m.F_Sint64Optional != nil { + return *m.F_Sint64Optional + } + return 0 +} + +func (m *GoTest) GetF_BoolDefaulted() bool { + if m != nil && m.F_BoolDefaulted != nil { + return *m.F_BoolDefaulted + } + return Default_GoTest_F_BoolDefaulted +} + +func (m *GoTest) GetF_Int32Defaulted() int32 { + if m != nil && m.F_Int32Defaulted != nil { + return *m.F_Int32Defaulted + } + return Default_GoTest_F_Int32Defaulted +} + +func (m *GoTest) GetF_Int64Defaulted() int64 { + if m != nil && m.F_Int64Defaulted != nil { + return *m.F_Int64Defaulted + } + return Default_GoTest_F_Int64Defaulted +} + +func (m *GoTest) GetF_Fixed32Defaulted() uint32 { + if m != nil && m.F_Fixed32Defaulted != nil { + return *m.F_Fixed32Defaulted + } + return Default_GoTest_F_Fixed32Defaulted +} + +func (m *GoTest) GetF_Fixed64Defaulted() uint64 { + if m != nil && m.F_Fixed64Defaulted != nil { + return *m.F_Fixed64Defaulted + } + return Default_GoTest_F_Fixed64Defaulted +} + +func (m *GoTest) GetF_Uint32Defaulted() uint32 { + if m != nil && m.F_Uint32Defaulted != nil { + return *m.F_Uint32Defaulted + } + return Default_GoTest_F_Uint32Defaulted +} + +func (m *GoTest) GetF_Uint64Defaulted() uint64 { + if m != nil && m.F_Uint64Defaulted != nil { + return *m.F_Uint64Defaulted + } + return Default_GoTest_F_Uint64Defaulted +} + +func (m *GoTest) GetF_FloatDefaulted() float32 { + if m != nil && m.F_FloatDefaulted != nil { + return *m.F_FloatDefaulted + } + return Default_GoTest_F_FloatDefaulted +} + +func (m *GoTest) GetF_DoubleDefaulted() float64 { + if m != nil && m.F_DoubleDefaulted != nil { + return *m.F_DoubleDefaulted + } + return Default_GoTest_F_DoubleDefaulted +} + +func (m *GoTest) GetF_StringDefaulted() string { + if m != nil && m.F_StringDefaulted != nil { + return *m.F_StringDefaulted + } + return Default_GoTest_F_StringDefaulted +} + +func (m *GoTest) GetF_BytesDefaulted() []byte { + if m != nil && m.F_BytesDefaulted != nil { + return m.F_BytesDefaulted + } + return append([]byte(nil), Default_GoTest_F_BytesDefaulted...) +} + +func (m *GoTest) GetF_Sint32Defaulted() int32 { + if m != nil && m.F_Sint32Defaulted != nil { + return *m.F_Sint32Defaulted + } + return Default_GoTest_F_Sint32Defaulted +} + +func (m *GoTest) GetF_Sint64Defaulted() int64 { + if m != nil && m.F_Sint64Defaulted != nil { + return *m.F_Sint64Defaulted + } + return Default_GoTest_F_Sint64Defaulted +} + +func (m *GoTest) GetF_BoolRepeatedPacked() []bool { + if m != nil { + return m.F_BoolRepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_Int32RepeatedPacked() []int32 { + if m != nil { + return m.F_Int32RepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_Int64RepeatedPacked() []int64 { + if m != nil { + return m.F_Int64RepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_Fixed32RepeatedPacked() []uint32 { + if m != nil { + return m.F_Fixed32RepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_Fixed64RepeatedPacked() []uint64 { + if m != nil { + return m.F_Fixed64RepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_Uint32RepeatedPacked() []uint32 { + if m != nil { + return m.F_Uint32RepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_Uint64RepeatedPacked() []uint64 { + if m != nil { + return m.F_Uint64RepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_FloatRepeatedPacked() []float32 { + if m != nil { + return m.F_FloatRepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_DoubleRepeatedPacked() []float64 { + if m != nil { + return m.F_DoubleRepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_Sint32RepeatedPacked() []int32 { + if m != nil { + return m.F_Sint32RepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_Sint64RepeatedPacked() []int64 { + if m != nil { + return m.F_Sint64RepeatedPacked + } + return nil +} + +func (m *GoTest) GetRequiredgroup() *GoTest_RequiredGroup { + if m != nil { + return m.Requiredgroup + } + return nil +} + +func (m *GoTest) GetRepeatedgroup() []*GoTest_RepeatedGroup { + if m != nil { + return m.Repeatedgroup + } + return nil +} + +func (m *GoTest) GetOptionalgroup() *GoTest_OptionalGroup { + if m != nil { + return m.Optionalgroup + } + return nil +} + +// Required, repeated, and optional groups. +type GoTest_RequiredGroup struct { + RequiredField *string `protobuf:"bytes,71,req,name=RequiredField" json:"RequiredField,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GoTest_RequiredGroup) Reset() { *m = GoTest_RequiredGroup{} } +func (m *GoTest_RequiredGroup) String() string { return proto.CompactTextString(m) } +func (*GoTest_RequiredGroup) ProtoMessage() {} + +func (m *GoTest_RequiredGroup) GetRequiredField() string { + if m != nil && m.RequiredField != nil { + return *m.RequiredField + } + return "" +} + +type GoTest_RepeatedGroup struct { + RequiredField *string `protobuf:"bytes,81,req,name=RequiredField" json:"RequiredField,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GoTest_RepeatedGroup) Reset() { *m = GoTest_RepeatedGroup{} } +func (m *GoTest_RepeatedGroup) String() string { return proto.CompactTextString(m) } +func (*GoTest_RepeatedGroup) ProtoMessage() {} + +func (m *GoTest_RepeatedGroup) GetRequiredField() string { + if m != nil && m.RequiredField != nil { + return *m.RequiredField + } + return "" +} + +type GoTest_OptionalGroup struct { + RequiredField *string `protobuf:"bytes,91,req,name=RequiredField" json:"RequiredField,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GoTest_OptionalGroup) Reset() { *m = GoTest_OptionalGroup{} } +func (m *GoTest_OptionalGroup) String() string { return proto.CompactTextString(m) } +func (*GoTest_OptionalGroup) ProtoMessage() {} + +func (m *GoTest_OptionalGroup) GetRequiredField() string { + if m != nil && m.RequiredField != nil { + return *m.RequiredField + } + return "" +} + +// For testing skipping of unrecognized fields. +// Numbers are all big, larger than tag numbers in GoTestField, +// the message used in the corresponding test. +type GoSkipTest struct { + SkipInt32 *int32 `protobuf:"varint,11,req,name=skip_int32" json:"skip_int32,omitempty"` + SkipFixed32 *uint32 `protobuf:"fixed32,12,req,name=skip_fixed32" json:"skip_fixed32,omitempty"` + SkipFixed64 *uint64 `protobuf:"fixed64,13,req,name=skip_fixed64" json:"skip_fixed64,omitempty"` + SkipString *string `protobuf:"bytes,14,req,name=skip_string" json:"skip_string,omitempty"` + Skipgroup *GoSkipTest_SkipGroup `protobuf:"group,15,req,name=SkipGroup" json:"skipgroup,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GoSkipTest) Reset() { *m = GoSkipTest{} } +func (m *GoSkipTest) String() string { return proto.CompactTextString(m) } +func (*GoSkipTest) ProtoMessage() {} + +func (m *GoSkipTest) GetSkipInt32() int32 { + if m != nil && m.SkipInt32 != nil { + return *m.SkipInt32 + } + return 0 +} + +func (m *GoSkipTest) GetSkipFixed32() uint32 { + if m != nil && m.SkipFixed32 != nil { + return *m.SkipFixed32 + } + return 0 +} + +func (m *GoSkipTest) GetSkipFixed64() uint64 { + if m != nil && m.SkipFixed64 != nil { + return *m.SkipFixed64 + } + return 0 +} + +func (m *GoSkipTest) GetSkipString() string { + if m != nil && m.SkipString != nil { + return *m.SkipString + } + return "" +} + +func (m *GoSkipTest) GetSkipgroup() *GoSkipTest_SkipGroup { + if m != nil { + return m.Skipgroup + } + return nil +} + +type GoSkipTest_SkipGroup struct { + GroupInt32 *int32 `protobuf:"varint,16,req,name=group_int32" json:"group_int32,omitempty"` + GroupString *string `protobuf:"bytes,17,req,name=group_string" json:"group_string,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GoSkipTest_SkipGroup) Reset() { *m = GoSkipTest_SkipGroup{} } +func (m *GoSkipTest_SkipGroup) String() string { return proto.CompactTextString(m) } +func (*GoSkipTest_SkipGroup) ProtoMessage() {} + +func (m *GoSkipTest_SkipGroup) GetGroupInt32() int32 { + if m != nil && m.GroupInt32 != nil { + return *m.GroupInt32 + } + return 0 +} + +func (m *GoSkipTest_SkipGroup) GetGroupString() string { + if m != nil && m.GroupString != nil { + return *m.GroupString + } + return "" +} + +// For testing packed/non-packed decoder switching. +// A serialized instance of one should be deserializable as the other. +type NonPackedTest struct { + A []int32 `protobuf:"varint,1,rep,name=a" json:"a,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NonPackedTest) Reset() { *m = NonPackedTest{} } +func (m *NonPackedTest) String() string { return proto.CompactTextString(m) } +func (*NonPackedTest) ProtoMessage() {} + +func (m *NonPackedTest) GetA() []int32 { + if m != nil { + return m.A + } + return nil +} + +type PackedTest struct { + B []int32 `protobuf:"varint,1,rep,packed,name=b" json:"b,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PackedTest) Reset() { *m = PackedTest{} } +func (m *PackedTest) String() string { return proto.CompactTextString(m) } +func (*PackedTest) ProtoMessage() {} + +func (m *PackedTest) GetB() []int32 { + if m != nil { + return m.B + } + return nil +} + +type MaxTag struct { + // Maximum possible tag number. + LastField *string `protobuf:"bytes,536870911,opt,name=last_field" json:"last_field,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MaxTag) Reset() { *m = MaxTag{} } +func (m *MaxTag) String() string { return proto.CompactTextString(m) } +func (*MaxTag) ProtoMessage() {} + +func (m *MaxTag) GetLastField() string { + if m != nil && m.LastField != nil { + return *m.LastField + } + return "" +} + +type OldMessage struct { + Nested *OldMessage_Nested `protobuf:"bytes,1,opt,name=nested" json:"nested,omitempty"` + Num *int32 `protobuf:"varint,2,opt,name=num" json:"num,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OldMessage) Reset() { *m = OldMessage{} } +func (m *OldMessage) String() string { return proto.CompactTextString(m) } +func (*OldMessage) ProtoMessage() {} + +func (m *OldMessage) GetNested() *OldMessage_Nested { + if m != nil { + return m.Nested + } + return nil +} + +func (m *OldMessage) GetNum() int32 { + if m != nil && m.Num != nil { + return *m.Num + } + return 0 +} + +type OldMessage_Nested struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OldMessage_Nested) Reset() { *m = OldMessage_Nested{} } +func (m *OldMessage_Nested) String() string { return proto.CompactTextString(m) } +func (*OldMessage_Nested) ProtoMessage() {} + +func (m *OldMessage_Nested) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +// NewMessage is wire compatible with OldMessage; +// imagine it as a future version. +type NewMessage struct { + Nested *NewMessage_Nested `protobuf:"bytes,1,opt,name=nested" json:"nested,omitempty"` + // This is an int32 in OldMessage. + Num *int64 `protobuf:"varint,2,opt,name=num" json:"num,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NewMessage) Reset() { *m = NewMessage{} } +func (m *NewMessage) String() string { return proto.CompactTextString(m) } +func (*NewMessage) ProtoMessage() {} + +func (m *NewMessage) GetNested() *NewMessage_Nested { + if m != nil { + return m.Nested + } + return nil +} + +func (m *NewMessage) GetNum() int64 { + if m != nil && m.Num != nil { + return *m.Num + } + return 0 +} + +type NewMessage_Nested struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + FoodGroup *string `protobuf:"bytes,2,opt,name=food_group" json:"food_group,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NewMessage_Nested) Reset() { *m = NewMessage_Nested{} } +func (m *NewMessage_Nested) String() string { return proto.CompactTextString(m) } +func (*NewMessage_Nested) ProtoMessage() {} + +func (m *NewMessage_Nested) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *NewMessage_Nested) GetFoodGroup() string { + if m != nil && m.FoodGroup != nil { + return *m.FoodGroup + } + return "" +} + +type InnerMessage struct { + Host *string `protobuf:"bytes,1,req,name=host" json:"host,omitempty"` + Port *int32 `protobuf:"varint,2,opt,name=port,def=4000" json:"port,omitempty"` + Connected *bool `protobuf:"varint,3,opt,name=connected" json:"connected,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *InnerMessage) Reset() { *m = InnerMessage{} } +func (m *InnerMessage) String() string { return proto.CompactTextString(m) } +func (*InnerMessage) ProtoMessage() {} + +const Default_InnerMessage_Port int32 = 4000 + +func (m *InnerMessage) GetHost() string { + if m != nil && m.Host != nil { + return *m.Host + } + return "" +} + +func (m *InnerMessage) GetPort() int32 { + if m != nil && m.Port != nil { + return *m.Port + } + return Default_InnerMessage_Port +} + +func (m *InnerMessage) GetConnected() bool { + if m != nil && m.Connected != nil { + return *m.Connected + } + return false +} + +type OtherMessage struct { + Key *int64 `protobuf:"varint,1,opt,name=key" json:"key,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` + Weight *float32 `protobuf:"fixed32,3,opt,name=weight" json:"weight,omitempty"` + Inner *InnerMessage `protobuf:"bytes,4,opt,name=inner" json:"inner,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OtherMessage) Reset() { *m = OtherMessage{} } +func (m *OtherMessage) String() string { return proto.CompactTextString(m) } +func (*OtherMessage) ProtoMessage() {} + +func (m *OtherMessage) GetKey() int64 { + if m != nil && m.Key != nil { + return *m.Key + } + return 0 +} + +func (m *OtherMessage) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +func (m *OtherMessage) GetWeight() float32 { + if m != nil && m.Weight != nil { + return *m.Weight + } + return 0 +} + +func (m *OtherMessage) GetInner() *InnerMessage { + if m != nil { + return m.Inner + } + return nil +} + +type MyMessage struct { + Count *int32 `protobuf:"varint,1,req,name=count" json:"count,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + Quote *string `protobuf:"bytes,3,opt,name=quote" json:"quote,omitempty"` + Pet []string `protobuf:"bytes,4,rep,name=pet" json:"pet,omitempty"` + Inner *InnerMessage `protobuf:"bytes,5,opt,name=inner" json:"inner,omitempty"` + Others []*OtherMessage `protobuf:"bytes,6,rep,name=others" json:"others,omitempty"` + RepInner []*InnerMessage `protobuf:"bytes,12,rep,name=rep_inner" json:"rep_inner,omitempty"` + Bikeshed *MyMessage_Color `protobuf:"varint,7,opt,name=bikeshed,enum=testdata.MyMessage_Color" json:"bikeshed,omitempty"` + Somegroup *MyMessage_SomeGroup `protobuf:"group,8,opt,name=SomeGroup" json:"somegroup,omitempty"` + // This field becomes [][]byte in the generated code. + RepBytes [][]byte `protobuf:"bytes,10,rep,name=rep_bytes" json:"rep_bytes,omitempty"` + Bigfloat *float64 `protobuf:"fixed64,11,opt,name=bigfloat" json:"bigfloat,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MyMessage) Reset() { *m = MyMessage{} } +func (m *MyMessage) String() string { return proto.CompactTextString(m) } +func (*MyMessage) ProtoMessage() {} + +var extRange_MyMessage = []proto.ExtensionRange{ + {100, 536870911}, +} + +func (*MyMessage) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MyMessage +} +func (m *MyMessage) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +func (m *MyMessage) GetCount() int32 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +func (m *MyMessage) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *MyMessage) GetQuote() string { + if m != nil && m.Quote != nil { + return *m.Quote + } + return "" +} + +func (m *MyMessage) GetPet() []string { + if m != nil { + return m.Pet + } + return nil +} + +func (m *MyMessage) GetInner() *InnerMessage { + if m != nil { + return m.Inner + } + return nil +} + +func (m *MyMessage) GetOthers() []*OtherMessage { + if m != nil { + return m.Others + } + return nil +} + +func (m *MyMessage) GetRepInner() []*InnerMessage { + if m != nil { + return m.RepInner + } + return nil +} + +func (m *MyMessage) GetBikeshed() MyMessage_Color { + if m != nil && m.Bikeshed != nil { + return *m.Bikeshed + } + return MyMessage_RED +} + +func (m *MyMessage) GetSomegroup() *MyMessage_SomeGroup { + if m != nil { + return m.Somegroup + } + return nil +} + +func (m *MyMessage) GetRepBytes() [][]byte { + if m != nil { + return m.RepBytes + } + return nil +} + +func (m *MyMessage) GetBigfloat() float64 { + if m != nil && m.Bigfloat != nil { + return *m.Bigfloat + } + return 0 +} + +type MyMessage_SomeGroup struct { + GroupField *int32 `protobuf:"varint,9,opt,name=group_field" json:"group_field,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MyMessage_SomeGroup) Reset() { *m = MyMessage_SomeGroup{} } +func (m *MyMessage_SomeGroup) String() string { return proto.CompactTextString(m) } +func (*MyMessage_SomeGroup) ProtoMessage() {} + +func (m *MyMessage_SomeGroup) GetGroupField() int32 { + if m != nil && m.GroupField != nil { + return *m.GroupField + } + return 0 +} + +type Ext struct { + Data *string `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Ext) Reset() { *m = Ext{} } +func (m *Ext) String() string { return proto.CompactTextString(m) } +func (*Ext) ProtoMessage() {} + +func (m *Ext) GetData() string { + if m != nil && m.Data != nil { + return *m.Data + } + return "" +} + +var E_Ext_More = &proto.ExtensionDesc{ + ExtendedType: (*MyMessage)(nil), + ExtensionType: (*Ext)(nil), + Field: 103, + Name: "testdata.Ext.more", + Tag: "bytes,103,opt,name=more", +} + +var E_Ext_Text = &proto.ExtensionDesc{ + ExtendedType: (*MyMessage)(nil), + ExtensionType: (*string)(nil), + Field: 104, + Name: "testdata.Ext.text", + Tag: "bytes,104,opt,name=text", +} + +var E_Ext_Number = &proto.ExtensionDesc{ + ExtendedType: (*MyMessage)(nil), + ExtensionType: (*int32)(nil), + Field: 105, + Name: "testdata.Ext.number", + Tag: "varint,105,opt,name=number", +} + +type DefaultsMessage struct { + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DefaultsMessage) Reset() { *m = DefaultsMessage{} } +func (m *DefaultsMessage) String() string { return proto.CompactTextString(m) } +func (*DefaultsMessage) ProtoMessage() {} + +var extRange_DefaultsMessage = []proto.ExtensionRange{ + {100, 536870911}, +} + +func (*DefaultsMessage) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_DefaultsMessage +} +func (m *DefaultsMessage) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type MyMessageSet struct { + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MyMessageSet) Reset() { *m = MyMessageSet{} } +func (m *MyMessageSet) String() string { return proto.CompactTextString(m) } +func (*MyMessageSet) ProtoMessage() {} + +func (m *MyMessageSet) Marshal() ([]byte, error) { + return proto.MarshalMessageSet(m.ExtensionMap()) +} +func (m *MyMessageSet) Unmarshal(buf []byte) error { + return proto.UnmarshalMessageSet(buf, m.ExtensionMap()) +} +func (m *MyMessageSet) MarshalJSON() ([]byte, error) { + return proto.MarshalMessageSetJSON(m.XXX_extensions) +} +func (m *MyMessageSet) UnmarshalJSON(buf []byte) error { + return proto.UnmarshalMessageSetJSON(buf, m.XXX_extensions) +} + +// ensure MyMessageSet satisfies proto.Marshaler and proto.Unmarshaler +var _ proto.Marshaler = (*MyMessageSet)(nil) +var _ proto.Unmarshaler = (*MyMessageSet)(nil) + +var extRange_MyMessageSet = []proto.ExtensionRange{ + {100, 2147483646}, +} + +func (*MyMessageSet) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MyMessageSet +} +func (m *MyMessageSet) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type Empty struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *Empty) Reset() { *m = Empty{} } +func (m *Empty) String() string { return proto.CompactTextString(m) } +func (*Empty) ProtoMessage() {} + +type MessageList struct { + Message []*MessageList_Message `protobuf:"group,1,rep,name=Message" json:"message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MessageList) Reset() { *m = MessageList{} } +func (m *MessageList) String() string { return proto.CompactTextString(m) } +func (*MessageList) ProtoMessage() {} + +func (m *MessageList) GetMessage() []*MessageList_Message { + if m != nil { + return m.Message + } + return nil +} + +type MessageList_Message struct { + Name *string `protobuf:"bytes,2,req,name=name" json:"name,omitempty"` + Count *int32 `protobuf:"varint,3,req,name=count" json:"count,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MessageList_Message) Reset() { *m = MessageList_Message{} } +func (m *MessageList_Message) String() string { return proto.CompactTextString(m) } +func (*MessageList_Message) ProtoMessage() {} + +func (m *MessageList_Message) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *MessageList_Message) GetCount() int32 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +type Strings struct { + StringField *string `protobuf:"bytes,1,opt,name=string_field" json:"string_field,omitempty"` + BytesField []byte `protobuf:"bytes,2,opt,name=bytes_field" json:"bytes_field,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Strings) Reset() { *m = Strings{} } +func (m *Strings) String() string { return proto.CompactTextString(m) } +func (*Strings) ProtoMessage() {} + +func (m *Strings) GetStringField() string { + if m != nil && m.StringField != nil { + return *m.StringField + } + return "" +} + +func (m *Strings) GetBytesField() []byte { + if m != nil { + return m.BytesField + } + return nil +} + +type Defaults struct { + // Default-valued fields of all basic types. + // Same as GoTest, but copied here to make testing easier. + F_Bool *bool `protobuf:"varint,1,opt,name=F_Bool,def=1" json:"F_Bool,omitempty"` + F_Int32 *int32 `protobuf:"varint,2,opt,name=F_Int32,def=32" json:"F_Int32,omitempty"` + F_Int64 *int64 `protobuf:"varint,3,opt,name=F_Int64,def=64" json:"F_Int64,omitempty"` + F_Fixed32 *uint32 `protobuf:"fixed32,4,opt,name=F_Fixed32,def=320" json:"F_Fixed32,omitempty"` + F_Fixed64 *uint64 `protobuf:"fixed64,5,opt,name=F_Fixed64,def=640" json:"F_Fixed64,omitempty"` + F_Uint32 *uint32 `protobuf:"varint,6,opt,name=F_Uint32,def=3200" json:"F_Uint32,omitempty"` + F_Uint64 *uint64 `protobuf:"varint,7,opt,name=F_Uint64,def=6400" json:"F_Uint64,omitempty"` + F_Float *float32 `protobuf:"fixed32,8,opt,name=F_Float,def=314159" json:"F_Float,omitempty"` + F_Double *float64 `protobuf:"fixed64,9,opt,name=F_Double,def=271828" json:"F_Double,omitempty"` + F_String *string `protobuf:"bytes,10,opt,name=F_String,def=hello, \"world!\"\n" json:"F_String,omitempty"` + F_Bytes []byte `protobuf:"bytes,11,opt,name=F_Bytes,def=Bignose" json:"F_Bytes,omitempty"` + F_Sint32 *int32 `protobuf:"zigzag32,12,opt,name=F_Sint32,def=-32" json:"F_Sint32,omitempty"` + F_Sint64 *int64 `protobuf:"zigzag64,13,opt,name=F_Sint64,def=-64" json:"F_Sint64,omitempty"` + F_Enum *Defaults_Color `protobuf:"varint,14,opt,name=F_Enum,enum=testdata.Defaults_Color,def=1" json:"F_Enum,omitempty"` + // More fields with crazy defaults. + F_Pinf *float32 `protobuf:"fixed32,15,opt,name=F_Pinf,def=inf" json:"F_Pinf,omitempty"` + F_Ninf *float32 `protobuf:"fixed32,16,opt,name=F_Ninf,def=-inf" json:"F_Ninf,omitempty"` + F_Nan *float32 `protobuf:"fixed32,17,opt,name=F_Nan,def=nan" json:"F_Nan,omitempty"` + // Sub-message. + Sub *SubDefaults `protobuf:"bytes,18,opt,name=sub" json:"sub,omitempty"` + // Redundant but explicit defaults. + StrZero *string `protobuf:"bytes,19,opt,name=str_zero,def=" json:"str_zero,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Defaults) Reset() { *m = Defaults{} } +func (m *Defaults) String() string { return proto.CompactTextString(m) } +func (*Defaults) ProtoMessage() {} + +const Default_Defaults_F_Bool bool = true +const Default_Defaults_F_Int32 int32 = 32 +const Default_Defaults_F_Int64 int64 = 64 +const Default_Defaults_F_Fixed32 uint32 = 320 +const Default_Defaults_F_Fixed64 uint64 = 640 +const Default_Defaults_F_Uint32 uint32 = 3200 +const Default_Defaults_F_Uint64 uint64 = 6400 +const Default_Defaults_F_Float float32 = 314159 +const Default_Defaults_F_Double float64 = 271828 +const Default_Defaults_F_String string = "hello, \"world!\"\n" + +var Default_Defaults_F_Bytes []byte = []byte("Bignose") + +const Default_Defaults_F_Sint32 int32 = -32 +const Default_Defaults_F_Sint64 int64 = -64 +const Default_Defaults_F_Enum Defaults_Color = Defaults_GREEN + +var Default_Defaults_F_Pinf float32 = float32(math.Inf(1)) +var Default_Defaults_F_Ninf float32 = float32(math.Inf(-1)) +var Default_Defaults_F_Nan float32 = float32(math.NaN()) + +func (m *Defaults) GetF_Bool() bool { + if m != nil && m.F_Bool != nil { + return *m.F_Bool + } + return Default_Defaults_F_Bool +} + +func (m *Defaults) GetF_Int32() int32 { + if m != nil && m.F_Int32 != nil { + return *m.F_Int32 + } + return Default_Defaults_F_Int32 +} + +func (m *Defaults) GetF_Int64() int64 { + if m != nil && m.F_Int64 != nil { + return *m.F_Int64 + } + return Default_Defaults_F_Int64 +} + +func (m *Defaults) GetF_Fixed32() uint32 { + if m != nil && m.F_Fixed32 != nil { + return *m.F_Fixed32 + } + return Default_Defaults_F_Fixed32 +} + +func (m *Defaults) GetF_Fixed64() uint64 { + if m != nil && m.F_Fixed64 != nil { + return *m.F_Fixed64 + } + return Default_Defaults_F_Fixed64 +} + +func (m *Defaults) GetF_Uint32() uint32 { + if m != nil && m.F_Uint32 != nil { + return *m.F_Uint32 + } + return Default_Defaults_F_Uint32 +} + +func (m *Defaults) GetF_Uint64() uint64 { + if m != nil && m.F_Uint64 != nil { + return *m.F_Uint64 + } + return Default_Defaults_F_Uint64 +} + +func (m *Defaults) GetF_Float() float32 { + if m != nil && m.F_Float != nil { + return *m.F_Float + } + return Default_Defaults_F_Float +} + +func (m *Defaults) GetF_Double() float64 { + if m != nil && m.F_Double != nil { + return *m.F_Double + } + return Default_Defaults_F_Double +} + +func (m *Defaults) GetF_String() string { + if m != nil && m.F_String != nil { + return *m.F_String + } + return Default_Defaults_F_String +} + +func (m *Defaults) GetF_Bytes() []byte { + if m != nil && m.F_Bytes != nil { + return m.F_Bytes + } + return append([]byte(nil), Default_Defaults_F_Bytes...) +} + +func (m *Defaults) GetF_Sint32() int32 { + if m != nil && m.F_Sint32 != nil { + return *m.F_Sint32 + } + return Default_Defaults_F_Sint32 +} + +func (m *Defaults) GetF_Sint64() int64 { + if m != nil && m.F_Sint64 != nil { + return *m.F_Sint64 + } + return Default_Defaults_F_Sint64 +} + +func (m *Defaults) GetF_Enum() Defaults_Color { + if m != nil && m.F_Enum != nil { + return *m.F_Enum + } + return Default_Defaults_F_Enum +} + +func (m *Defaults) GetF_Pinf() float32 { + if m != nil && m.F_Pinf != nil { + return *m.F_Pinf + } + return Default_Defaults_F_Pinf +} + +func (m *Defaults) GetF_Ninf() float32 { + if m != nil && m.F_Ninf != nil { + return *m.F_Ninf + } + return Default_Defaults_F_Ninf +} + +func (m *Defaults) GetF_Nan() float32 { + if m != nil && m.F_Nan != nil { + return *m.F_Nan + } + return Default_Defaults_F_Nan +} + +func (m *Defaults) GetSub() *SubDefaults { + if m != nil { + return m.Sub + } + return nil +} + +func (m *Defaults) GetStrZero() string { + if m != nil && m.StrZero != nil { + return *m.StrZero + } + return "" +} + +type SubDefaults struct { + N *int64 `protobuf:"varint,1,opt,name=n,def=7" json:"n,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SubDefaults) Reset() { *m = SubDefaults{} } +func (m *SubDefaults) String() string { return proto.CompactTextString(m) } +func (*SubDefaults) ProtoMessage() {} + +const Default_SubDefaults_N int64 = 7 + +func (m *SubDefaults) GetN() int64 { + if m != nil && m.N != nil { + return *m.N + } + return Default_SubDefaults_N +} + +type RepeatedEnum struct { + Color []RepeatedEnum_Color `protobuf:"varint,1,rep,name=color,enum=testdata.RepeatedEnum_Color" json:"color,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *RepeatedEnum) Reset() { *m = RepeatedEnum{} } +func (m *RepeatedEnum) String() string { return proto.CompactTextString(m) } +func (*RepeatedEnum) ProtoMessage() {} + +func (m *RepeatedEnum) GetColor() []RepeatedEnum_Color { + if m != nil { + return m.Color + } + return nil +} + +type MoreRepeated struct { + Bools []bool `protobuf:"varint,1,rep,name=bools" json:"bools,omitempty"` + BoolsPacked []bool `protobuf:"varint,2,rep,packed,name=bools_packed" json:"bools_packed,omitempty"` + Ints []int32 `protobuf:"varint,3,rep,name=ints" json:"ints,omitempty"` + IntsPacked []int32 `protobuf:"varint,4,rep,packed,name=ints_packed" json:"ints_packed,omitempty"` + Int64SPacked []int64 `protobuf:"varint,7,rep,packed,name=int64s_packed" json:"int64s_packed,omitempty"` + Strings []string `protobuf:"bytes,5,rep,name=strings" json:"strings,omitempty"` + Fixeds []uint32 `protobuf:"fixed32,6,rep,name=fixeds" json:"fixeds,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MoreRepeated) Reset() { *m = MoreRepeated{} } +func (m *MoreRepeated) String() string { return proto.CompactTextString(m) } +func (*MoreRepeated) ProtoMessage() {} + +func (m *MoreRepeated) GetBools() []bool { + if m != nil { + return m.Bools + } + return nil +} + +func (m *MoreRepeated) GetBoolsPacked() []bool { + if m != nil { + return m.BoolsPacked + } + return nil +} + +func (m *MoreRepeated) GetInts() []int32 { + if m != nil { + return m.Ints + } + return nil +} + +func (m *MoreRepeated) GetIntsPacked() []int32 { + if m != nil { + return m.IntsPacked + } + return nil +} + +func (m *MoreRepeated) GetInt64SPacked() []int64 { + if m != nil { + return m.Int64SPacked + } + return nil +} + +func (m *MoreRepeated) GetStrings() []string { + if m != nil { + return m.Strings + } + return nil +} + +func (m *MoreRepeated) GetFixeds() []uint32 { + if m != nil { + return m.Fixeds + } + return nil +} + +type GroupOld struct { + G *GroupOld_G `protobuf:"group,101,opt,name=G" json:"g,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GroupOld) Reset() { *m = GroupOld{} } +func (m *GroupOld) String() string { return proto.CompactTextString(m) } +func (*GroupOld) ProtoMessage() {} + +func (m *GroupOld) GetG() *GroupOld_G { + if m != nil { + return m.G + } + return nil +} + +type GroupOld_G struct { + X *int32 `protobuf:"varint,2,opt,name=x" json:"x,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GroupOld_G) Reset() { *m = GroupOld_G{} } +func (m *GroupOld_G) String() string { return proto.CompactTextString(m) } +func (*GroupOld_G) ProtoMessage() {} + +func (m *GroupOld_G) GetX() int32 { + if m != nil && m.X != nil { + return *m.X + } + return 0 +} + +type GroupNew struct { + G *GroupNew_G `protobuf:"group,101,opt,name=G" json:"g,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GroupNew) Reset() { *m = GroupNew{} } +func (m *GroupNew) String() string { return proto.CompactTextString(m) } +func (*GroupNew) ProtoMessage() {} + +func (m *GroupNew) GetG() *GroupNew_G { + if m != nil { + return m.G + } + return nil +} + +type GroupNew_G struct { + X *int32 `protobuf:"varint,2,opt,name=x" json:"x,omitempty"` + Y *int32 `protobuf:"varint,3,opt,name=y" json:"y,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GroupNew_G) Reset() { *m = GroupNew_G{} } +func (m *GroupNew_G) String() string { return proto.CompactTextString(m) } +func (*GroupNew_G) ProtoMessage() {} + +func (m *GroupNew_G) GetX() int32 { + if m != nil && m.X != nil { + return *m.X + } + return 0 +} + +func (m *GroupNew_G) GetY() int32 { + if m != nil && m.Y != nil { + return *m.Y + } + return 0 +} + +type FloatingPoint struct { + F *float64 `protobuf:"fixed64,1,req,name=f" json:"f,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FloatingPoint) Reset() { *m = FloatingPoint{} } +func (m *FloatingPoint) String() string { return proto.CompactTextString(m) } +func (*FloatingPoint) ProtoMessage() {} + +func (m *FloatingPoint) GetF() float64 { + if m != nil && m.F != nil { + return *m.F + } + return 0 +} + +type MessageWithMap struct { + NameMapping map[int32]string `protobuf:"bytes,1,rep,name=name_mapping" json:"name_mapping,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + MsgMapping map[int64]*FloatingPoint `protobuf:"bytes,2,rep,name=msg_mapping" json:"msg_mapping,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + ByteMapping map[bool][]byte `protobuf:"bytes,3,rep,name=byte_mapping" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + StrToStr map[string]string `protobuf:"bytes,4,rep,name=str_to_str" json:"str_to_str,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MessageWithMap) Reset() { *m = MessageWithMap{} } +func (m *MessageWithMap) String() string { return proto.CompactTextString(m) } +func (*MessageWithMap) ProtoMessage() {} + +func (m *MessageWithMap) GetNameMapping() map[int32]string { + if m != nil { + return m.NameMapping + } + return nil +} + +func (m *MessageWithMap) GetMsgMapping() map[int64]*FloatingPoint { + if m != nil { + return m.MsgMapping + } + return nil +} + +func (m *MessageWithMap) GetByteMapping() map[bool][]byte { + if m != nil { + return m.ByteMapping + } + return nil +} + +func (m *MessageWithMap) GetStrToStr() map[string]string { + if m != nil { + return m.StrToStr + } + return nil +} + +type Communique struct { + MakeMeCry *bool `protobuf:"varint,1,opt,name=make_me_cry" json:"make_me_cry,omitempty"` + // This is a oneof, called "union". + // + // Types that are valid to be assigned to Union: + // *Communique_Number + // *Communique_Name + // *Communique_Data + // *Communique_TempC + // *Communique_Col + // *Communique_Msg + Union isCommunique_Union `protobuf_oneof:"union"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Communique) Reset() { *m = Communique{} } +func (m *Communique) String() string { return proto.CompactTextString(m) } +func (*Communique) ProtoMessage() {} + +type isCommunique_Union interface { + isCommunique_Union() +} + +type Communique_Number struct { + Number int32 `protobuf:"varint,5,opt,name=number,oneof"` +} +type Communique_Name struct { + Name string `protobuf:"bytes,6,opt,name=name,oneof"` +} +type Communique_Data struct { + Data []byte `protobuf:"bytes,7,opt,name=data,oneof"` +} +type Communique_TempC struct { + TempC float64 `protobuf:"fixed64,8,opt,name=temp_c,oneof"` +} +type Communique_Col struct { + Col MyMessage_Color `protobuf:"varint,9,opt,name=col,enum=testdata.MyMessage_Color,oneof"` +} +type Communique_Msg struct { + Msg *Strings `protobuf:"bytes,10,opt,name=msg,oneof"` +} + +func (*Communique_Number) isCommunique_Union() {} +func (*Communique_Name) isCommunique_Union() {} +func (*Communique_Data) isCommunique_Union() {} +func (*Communique_TempC) isCommunique_Union() {} +func (*Communique_Col) isCommunique_Union() {} +func (*Communique_Msg) isCommunique_Union() {} + +func (m *Communique) GetUnion() isCommunique_Union { + if m != nil { + return m.Union + } + return nil +} + +func (m *Communique) GetMakeMeCry() bool { + if m != nil && m.MakeMeCry != nil { + return *m.MakeMeCry + } + return false +} + +func (m *Communique) GetNumber() int32 { + if x, ok := m.GetUnion().(*Communique_Number); ok { + return x.Number + } + return 0 +} + +func (m *Communique) GetName() string { + if x, ok := m.GetUnion().(*Communique_Name); ok { + return x.Name + } + return "" +} + +func (m *Communique) GetData() []byte { + if x, ok := m.GetUnion().(*Communique_Data); ok { + return x.Data + } + return nil +} + +func (m *Communique) GetTempC() float64 { + if x, ok := m.GetUnion().(*Communique_TempC); ok { + return x.TempC + } + return 0 +} + +func (m *Communique) GetCol() MyMessage_Color { + if x, ok := m.GetUnion().(*Communique_Col); ok { + return x.Col + } + return MyMessage_RED +} + +func (m *Communique) GetMsg() *Strings { + if x, ok := m.GetUnion().(*Communique_Msg); ok { + return x.Msg + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*Communique) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _Communique_OneofMarshaler, _Communique_OneofUnmarshaler, []interface{}{ + (*Communique_Number)(nil), + (*Communique_Name)(nil), + (*Communique_Data)(nil), + (*Communique_TempC)(nil), + (*Communique_Col)(nil), + (*Communique_Msg)(nil), + } +} + +func _Communique_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*Communique) + // union + switch x := m.Union.(type) { + case *Communique_Number: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Number)) + case *Communique_Name: + _ = b.EncodeVarint(6<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Name) + case *Communique_Data: + _ = b.EncodeVarint(7<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Data) + case *Communique_TempC: + _ = b.EncodeVarint(8<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.TempC)) + case *Communique_Col: + _ = b.EncodeVarint(9<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Col)) + case *Communique_Msg: + _ = b.EncodeVarint(10<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.Msg); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("Communique.Union has unexpected type %T", x) + } + return nil +} + +func _Communique_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*Communique) + switch tag { + case 5: // union.number + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Union = &Communique_Number{int32(x)} + return true, err + case 6: // union.name + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Union = &Communique_Name{x} + return true, err + case 7: // union.data + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.Union = &Communique_Data{x} + return true, err + case 8: // union.temp_c + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.Union = &Communique_TempC{math.Float64frombits(x)} + return true, err + case 9: // union.col + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Union = &Communique_Col{MyMessage_Color(x)} + return true, err + case 10: // union.msg + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Strings) + err := b.DecodeMessage(msg) + m.Union = &Communique_Msg{msg} + return true, err + default: + return false, nil + } +} + +var E_Greeting = &proto.ExtensionDesc{ + ExtendedType: (*MyMessage)(nil), + ExtensionType: ([]string)(nil), + Field: 106, + Name: "testdata.greeting", + Tag: "bytes,106,rep,name=greeting", +} + +var E_NoDefaultDouble = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*float64)(nil), + Field: 101, + Name: "testdata.no_default_double", + Tag: "fixed64,101,opt,name=no_default_double", +} + +var E_NoDefaultFloat = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*float32)(nil), + Field: 102, + Name: "testdata.no_default_float", + Tag: "fixed32,102,opt,name=no_default_float", +} + +var E_NoDefaultInt32 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*int32)(nil), + Field: 103, + Name: "testdata.no_default_int32", + Tag: "varint,103,opt,name=no_default_int32", +} + +var E_NoDefaultInt64 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*int64)(nil), + Field: 104, + Name: "testdata.no_default_int64", + Tag: "varint,104,opt,name=no_default_int64", +} + +var E_NoDefaultUint32 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*uint32)(nil), + Field: 105, + Name: "testdata.no_default_uint32", + Tag: "varint,105,opt,name=no_default_uint32", +} + +var E_NoDefaultUint64 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*uint64)(nil), + Field: 106, + Name: "testdata.no_default_uint64", + Tag: "varint,106,opt,name=no_default_uint64", +} + +var E_NoDefaultSint32 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*int32)(nil), + Field: 107, + Name: "testdata.no_default_sint32", + Tag: "zigzag32,107,opt,name=no_default_sint32", +} + +var E_NoDefaultSint64 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*int64)(nil), + Field: 108, + Name: "testdata.no_default_sint64", + Tag: "zigzag64,108,opt,name=no_default_sint64", +} + +var E_NoDefaultFixed32 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*uint32)(nil), + Field: 109, + Name: "testdata.no_default_fixed32", + Tag: "fixed32,109,opt,name=no_default_fixed32", +} + +var E_NoDefaultFixed64 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*uint64)(nil), + Field: 110, + Name: "testdata.no_default_fixed64", + Tag: "fixed64,110,opt,name=no_default_fixed64", +} + +var E_NoDefaultSfixed32 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*int32)(nil), + Field: 111, + Name: "testdata.no_default_sfixed32", + Tag: "fixed32,111,opt,name=no_default_sfixed32", +} + +var E_NoDefaultSfixed64 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*int64)(nil), + Field: 112, + Name: "testdata.no_default_sfixed64", + Tag: "fixed64,112,opt,name=no_default_sfixed64", +} + +var E_NoDefaultBool = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*bool)(nil), + Field: 113, + Name: "testdata.no_default_bool", + Tag: "varint,113,opt,name=no_default_bool", +} + +var E_NoDefaultString = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*string)(nil), + Field: 114, + Name: "testdata.no_default_string", + Tag: "bytes,114,opt,name=no_default_string", +} + +var E_NoDefaultBytes = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: ([]byte)(nil), + Field: 115, + Name: "testdata.no_default_bytes", + Tag: "bytes,115,opt,name=no_default_bytes", +} + +var E_NoDefaultEnum = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*DefaultsMessage_DefaultsEnum)(nil), + Field: 116, + Name: "testdata.no_default_enum", + Tag: "varint,116,opt,name=no_default_enum,enum=testdata.DefaultsMessage_DefaultsEnum", +} + +var E_DefaultDouble = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*float64)(nil), + Field: 201, + Name: "testdata.default_double", + Tag: "fixed64,201,opt,name=default_double,def=3.1415", +} + +var E_DefaultFloat = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*float32)(nil), + Field: 202, + Name: "testdata.default_float", + Tag: "fixed32,202,opt,name=default_float,def=3.14", +} + +var E_DefaultInt32 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*int32)(nil), + Field: 203, + Name: "testdata.default_int32", + Tag: "varint,203,opt,name=default_int32,def=42", +} + +var E_DefaultInt64 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*int64)(nil), + Field: 204, + Name: "testdata.default_int64", + Tag: "varint,204,opt,name=default_int64,def=43", +} + +var E_DefaultUint32 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*uint32)(nil), + Field: 205, + Name: "testdata.default_uint32", + Tag: "varint,205,opt,name=default_uint32,def=44", +} + +var E_DefaultUint64 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*uint64)(nil), + Field: 206, + Name: "testdata.default_uint64", + Tag: "varint,206,opt,name=default_uint64,def=45", +} + +var E_DefaultSint32 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*int32)(nil), + Field: 207, + Name: "testdata.default_sint32", + Tag: "zigzag32,207,opt,name=default_sint32,def=46", +} + +var E_DefaultSint64 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*int64)(nil), + Field: 208, + Name: "testdata.default_sint64", + Tag: "zigzag64,208,opt,name=default_sint64,def=47", +} + +var E_DefaultFixed32 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*uint32)(nil), + Field: 209, + Name: "testdata.default_fixed32", + Tag: "fixed32,209,opt,name=default_fixed32,def=48", +} + +var E_DefaultFixed64 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*uint64)(nil), + Field: 210, + Name: "testdata.default_fixed64", + Tag: "fixed64,210,opt,name=default_fixed64,def=49", +} + +var E_DefaultSfixed32 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*int32)(nil), + Field: 211, + Name: "testdata.default_sfixed32", + Tag: "fixed32,211,opt,name=default_sfixed32,def=50", +} + +var E_DefaultSfixed64 = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*int64)(nil), + Field: 212, + Name: "testdata.default_sfixed64", + Tag: "fixed64,212,opt,name=default_sfixed64,def=51", +} + +var E_DefaultBool = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*bool)(nil), + Field: 213, + Name: "testdata.default_bool", + Tag: "varint,213,opt,name=default_bool,def=1", +} + +var E_DefaultString = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*string)(nil), + Field: 214, + Name: "testdata.default_string", + Tag: "bytes,214,opt,name=default_string,def=Hello, string", +} + +var E_DefaultBytes = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: ([]byte)(nil), + Field: 215, + Name: "testdata.default_bytes", + Tag: "bytes,215,opt,name=default_bytes,def=Hello, bytes", +} + +var E_DefaultEnum = &proto.ExtensionDesc{ + ExtendedType: (*DefaultsMessage)(nil), + ExtensionType: (*DefaultsMessage_DefaultsEnum)(nil), + Field: 216, + Name: "testdata.default_enum", + Tag: "varint,216,opt,name=default_enum,enum=testdata.DefaultsMessage_DefaultsEnum,def=1", +} + +var E_X201 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 201, + Name: "testdata.x201", + Tag: "bytes,201,opt,name=x201", +} + +var E_X202 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 202, + Name: "testdata.x202", + Tag: "bytes,202,opt,name=x202", +} + +var E_X203 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 203, + Name: "testdata.x203", + Tag: "bytes,203,opt,name=x203", +} + +var E_X204 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 204, + Name: "testdata.x204", + Tag: "bytes,204,opt,name=x204", +} + +var E_X205 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 205, + Name: "testdata.x205", + Tag: "bytes,205,opt,name=x205", +} + +var E_X206 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 206, + Name: "testdata.x206", + Tag: "bytes,206,opt,name=x206", +} + +var E_X207 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 207, + Name: "testdata.x207", + Tag: "bytes,207,opt,name=x207", +} + +var E_X208 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 208, + Name: "testdata.x208", + Tag: "bytes,208,opt,name=x208", +} + +var E_X209 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 209, + Name: "testdata.x209", + Tag: "bytes,209,opt,name=x209", +} + +var E_X210 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 210, + Name: "testdata.x210", + Tag: "bytes,210,opt,name=x210", +} + +var E_X211 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 211, + Name: "testdata.x211", + Tag: "bytes,211,opt,name=x211", +} + +var E_X212 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 212, + Name: "testdata.x212", + Tag: "bytes,212,opt,name=x212", +} + +var E_X213 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 213, + Name: "testdata.x213", + Tag: "bytes,213,opt,name=x213", +} + +var E_X214 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 214, + Name: "testdata.x214", + Tag: "bytes,214,opt,name=x214", +} + +var E_X215 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 215, + Name: "testdata.x215", + Tag: "bytes,215,opt,name=x215", +} + +var E_X216 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 216, + Name: "testdata.x216", + Tag: "bytes,216,opt,name=x216", +} + +var E_X217 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 217, + Name: "testdata.x217", + Tag: "bytes,217,opt,name=x217", +} + +var E_X218 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 218, + Name: "testdata.x218", + Tag: "bytes,218,opt,name=x218", +} + +var E_X219 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 219, + Name: "testdata.x219", + Tag: "bytes,219,opt,name=x219", +} + +var E_X220 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 220, + Name: "testdata.x220", + Tag: "bytes,220,opt,name=x220", +} + +var E_X221 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 221, + Name: "testdata.x221", + Tag: "bytes,221,opt,name=x221", +} + +var E_X222 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 222, + Name: "testdata.x222", + Tag: "bytes,222,opt,name=x222", +} + +var E_X223 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 223, + Name: "testdata.x223", + Tag: "bytes,223,opt,name=x223", +} + +var E_X224 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 224, + Name: "testdata.x224", + Tag: "bytes,224,opt,name=x224", +} + +var E_X225 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 225, + Name: "testdata.x225", + Tag: "bytes,225,opt,name=x225", +} + +var E_X226 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 226, + Name: "testdata.x226", + Tag: "bytes,226,opt,name=x226", +} + +var E_X227 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 227, + Name: "testdata.x227", + Tag: "bytes,227,opt,name=x227", +} + +var E_X228 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 228, + Name: "testdata.x228", + Tag: "bytes,228,opt,name=x228", +} + +var E_X229 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 229, + Name: "testdata.x229", + Tag: "bytes,229,opt,name=x229", +} + +var E_X230 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 230, + Name: "testdata.x230", + Tag: "bytes,230,opt,name=x230", +} + +var E_X231 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 231, + Name: "testdata.x231", + Tag: "bytes,231,opt,name=x231", +} + +var E_X232 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 232, + Name: "testdata.x232", + Tag: "bytes,232,opt,name=x232", +} + +var E_X233 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 233, + Name: "testdata.x233", + Tag: "bytes,233,opt,name=x233", +} + +var E_X234 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 234, + Name: "testdata.x234", + Tag: "bytes,234,opt,name=x234", +} + +var E_X235 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 235, + Name: "testdata.x235", + Tag: "bytes,235,opt,name=x235", +} + +var E_X236 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 236, + Name: "testdata.x236", + Tag: "bytes,236,opt,name=x236", +} + +var E_X237 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 237, + Name: "testdata.x237", + Tag: "bytes,237,opt,name=x237", +} + +var E_X238 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 238, + Name: "testdata.x238", + Tag: "bytes,238,opt,name=x238", +} + +var E_X239 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 239, + Name: "testdata.x239", + Tag: "bytes,239,opt,name=x239", +} + +var E_X240 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 240, + Name: "testdata.x240", + Tag: "bytes,240,opt,name=x240", +} + +var E_X241 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 241, + Name: "testdata.x241", + Tag: "bytes,241,opt,name=x241", +} + +var E_X242 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 242, + Name: "testdata.x242", + Tag: "bytes,242,opt,name=x242", +} + +var E_X243 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 243, + Name: "testdata.x243", + Tag: "bytes,243,opt,name=x243", +} + +var E_X244 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 244, + Name: "testdata.x244", + Tag: "bytes,244,opt,name=x244", +} + +var E_X245 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 245, + Name: "testdata.x245", + Tag: "bytes,245,opt,name=x245", +} + +var E_X246 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 246, + Name: "testdata.x246", + Tag: "bytes,246,opt,name=x246", +} + +var E_X247 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 247, + Name: "testdata.x247", + Tag: "bytes,247,opt,name=x247", +} + +var E_X248 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 248, + Name: "testdata.x248", + Tag: "bytes,248,opt,name=x248", +} + +var E_X249 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 249, + Name: "testdata.x249", + Tag: "bytes,249,opt,name=x249", +} + +var E_X250 = &proto.ExtensionDesc{ + ExtendedType: (*MyMessageSet)(nil), + ExtensionType: (*Empty)(nil), + Field: 250, + Name: "testdata.x250", + Tag: "bytes,250,opt,name=x250", +} + +func init() { + proto.RegisterEnum("testdata.FOO", FOO_name, FOO_value) + proto.RegisterEnum("testdata.GoTest_KIND", GoTest_KIND_name, GoTest_KIND_value) + proto.RegisterEnum("testdata.MyMessage_Color", MyMessage_Color_name, MyMessage_Color_value) + proto.RegisterEnum("testdata.DefaultsMessage_DefaultsEnum", DefaultsMessage_DefaultsEnum_name, DefaultsMessage_DefaultsEnum_value) + proto.RegisterEnum("testdata.Defaults_Color", Defaults_Color_name, Defaults_Color_value) + proto.RegisterEnum("testdata.RepeatedEnum_Color", RepeatedEnum_Color_name, RepeatedEnum_Color_value) + proto.RegisterExtension(E_Ext_More) + proto.RegisterExtension(E_Ext_Text) + proto.RegisterExtension(E_Ext_Number) + proto.RegisterExtension(E_Greeting) + proto.RegisterExtension(E_NoDefaultDouble) + proto.RegisterExtension(E_NoDefaultFloat) + proto.RegisterExtension(E_NoDefaultInt32) + proto.RegisterExtension(E_NoDefaultInt64) + proto.RegisterExtension(E_NoDefaultUint32) + proto.RegisterExtension(E_NoDefaultUint64) + proto.RegisterExtension(E_NoDefaultSint32) + proto.RegisterExtension(E_NoDefaultSint64) + proto.RegisterExtension(E_NoDefaultFixed32) + proto.RegisterExtension(E_NoDefaultFixed64) + proto.RegisterExtension(E_NoDefaultSfixed32) + proto.RegisterExtension(E_NoDefaultSfixed64) + proto.RegisterExtension(E_NoDefaultBool) + proto.RegisterExtension(E_NoDefaultString) + proto.RegisterExtension(E_NoDefaultBytes) + proto.RegisterExtension(E_NoDefaultEnum) + proto.RegisterExtension(E_DefaultDouble) + proto.RegisterExtension(E_DefaultFloat) + proto.RegisterExtension(E_DefaultInt32) + proto.RegisterExtension(E_DefaultInt64) + proto.RegisterExtension(E_DefaultUint32) + proto.RegisterExtension(E_DefaultUint64) + proto.RegisterExtension(E_DefaultSint32) + proto.RegisterExtension(E_DefaultSint64) + proto.RegisterExtension(E_DefaultFixed32) + proto.RegisterExtension(E_DefaultFixed64) + proto.RegisterExtension(E_DefaultSfixed32) + proto.RegisterExtension(E_DefaultSfixed64) + proto.RegisterExtension(E_DefaultBool) + proto.RegisterExtension(E_DefaultString) + proto.RegisterExtension(E_DefaultBytes) + proto.RegisterExtension(E_DefaultEnum) + proto.RegisterExtension(E_X201) + proto.RegisterExtension(E_X202) + proto.RegisterExtension(E_X203) + proto.RegisterExtension(E_X204) + proto.RegisterExtension(E_X205) + proto.RegisterExtension(E_X206) + proto.RegisterExtension(E_X207) + proto.RegisterExtension(E_X208) + proto.RegisterExtension(E_X209) + proto.RegisterExtension(E_X210) + proto.RegisterExtension(E_X211) + proto.RegisterExtension(E_X212) + proto.RegisterExtension(E_X213) + proto.RegisterExtension(E_X214) + proto.RegisterExtension(E_X215) + proto.RegisterExtension(E_X216) + proto.RegisterExtension(E_X217) + proto.RegisterExtension(E_X218) + proto.RegisterExtension(E_X219) + proto.RegisterExtension(E_X220) + proto.RegisterExtension(E_X221) + proto.RegisterExtension(E_X222) + proto.RegisterExtension(E_X223) + proto.RegisterExtension(E_X224) + proto.RegisterExtension(E_X225) + proto.RegisterExtension(E_X226) + proto.RegisterExtension(E_X227) + proto.RegisterExtension(E_X228) + proto.RegisterExtension(E_X229) + proto.RegisterExtension(E_X230) + proto.RegisterExtension(E_X231) + proto.RegisterExtension(E_X232) + proto.RegisterExtension(E_X233) + proto.RegisterExtension(E_X234) + proto.RegisterExtension(E_X235) + proto.RegisterExtension(E_X236) + proto.RegisterExtension(E_X237) + proto.RegisterExtension(E_X238) + proto.RegisterExtension(E_X239) + proto.RegisterExtension(E_X240) + proto.RegisterExtension(E_X241) + proto.RegisterExtension(E_X242) + proto.RegisterExtension(E_X243) + proto.RegisterExtension(E_X244) + proto.RegisterExtension(E_X245) + proto.RegisterExtension(E_X246) + proto.RegisterExtension(E_X247) + proto.RegisterExtension(E_X248) + proto.RegisterExtension(E_X249) + proto.RegisterExtension(E_X250) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata/test.pb.go.golden b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata/test.pb.go.golden new file mode 100644 index 0000000000000000000000000000000000000000..0387853d56c614215907e03f7b2be40a4a327536 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata/test.pb.go.golden @@ -0,0 +1,1737 @@ +// Code generated by protoc-gen-gogo. +// source: test.proto +// DO NOT EDIT! + +package testdata + +import proto "github.com/gogo/protobuf/proto" +import json "encoding/json" +import math "math" + +import () + +// Reference proto, json, and math imports to suppress error if they are not otherwise used. +var _ = proto.Marshal +var _ = &json.SyntaxError{} +var _ = math.Inf + +type FOO int32 + +const ( + FOO_FOO1 FOO = 1 +) + +var FOO_name = map[int32]string{ + 1: "FOO1", +} +var FOO_value = map[string]int32{ + "FOO1": 1, +} + +func (x FOO) Enum() *FOO { + p := new(FOO) + *p = x + return p +} +func (x FOO) String() string { + return proto.EnumName(FOO_name, int32(x)) +} +func (x FOO) MarshalJSON() ([]byte, error) { + return json.Marshal(x.String()) +} +func (x *FOO) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FOO_value, data, "FOO") + if err != nil { + return err + } + *x = FOO(value) + return nil +} + +type GoTest_KIND int32 + +const ( + GoTest_VOID GoTest_KIND = 0 + GoTest_BOOL GoTest_KIND = 1 + GoTest_BYTES GoTest_KIND = 2 + GoTest_FINGERPRINT GoTest_KIND = 3 + GoTest_FLOAT GoTest_KIND = 4 + GoTest_INT GoTest_KIND = 5 + GoTest_STRING GoTest_KIND = 6 + GoTest_TIME GoTest_KIND = 7 + GoTest_TUPLE GoTest_KIND = 8 + GoTest_ARRAY GoTest_KIND = 9 + GoTest_MAP GoTest_KIND = 10 + GoTest_TABLE GoTest_KIND = 11 + GoTest_FUNCTION GoTest_KIND = 12 +) + +var GoTest_KIND_name = map[int32]string{ + 0: "VOID", + 1: "BOOL", + 2: "BYTES", + 3: "FINGERPRINT", + 4: "FLOAT", + 5: "INT", + 6: "STRING", + 7: "TIME", + 8: "TUPLE", + 9: "ARRAY", + 10: "MAP", + 11: "TABLE", + 12: "FUNCTION", +} +var GoTest_KIND_value = map[string]int32{ + "VOID": 0, + "BOOL": 1, + "BYTES": 2, + "FINGERPRINT": 3, + "FLOAT": 4, + "INT": 5, + "STRING": 6, + "TIME": 7, + "TUPLE": 8, + "ARRAY": 9, + "MAP": 10, + "TABLE": 11, + "FUNCTION": 12, +} + +func (x GoTest_KIND) Enum() *GoTest_KIND { + p := new(GoTest_KIND) + *p = x + return p +} +func (x GoTest_KIND) String() string { + return proto.EnumName(GoTest_KIND_name, int32(x)) +} +func (x GoTest_KIND) MarshalJSON() ([]byte, error) { + return json.Marshal(x.String()) +} +func (x *GoTest_KIND) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(GoTest_KIND_value, data, "GoTest_KIND") + if err != nil { + return err + } + *x = GoTest_KIND(value) + return nil +} + +type MyMessage_Color int32 + +const ( + MyMessage_RED MyMessage_Color = 0 + MyMessage_GREEN MyMessage_Color = 1 + MyMessage_BLUE MyMessage_Color = 2 +) + +var MyMessage_Color_name = map[int32]string{ + 0: "RED", + 1: "GREEN", + 2: "BLUE", +} +var MyMessage_Color_value = map[string]int32{ + "RED": 0, + "GREEN": 1, + "BLUE": 2, +} + +func (x MyMessage_Color) Enum() *MyMessage_Color { + p := new(MyMessage_Color) + *p = x + return p +} +func (x MyMessage_Color) String() string { + return proto.EnumName(MyMessage_Color_name, int32(x)) +} +func (x MyMessage_Color) MarshalJSON() ([]byte, error) { + return json.Marshal(x.String()) +} +func (x *MyMessage_Color) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(MyMessage_Color_value, data, "MyMessage_Color") + if err != nil { + return err + } + *x = MyMessage_Color(value) + return nil +} + +type Defaults_Color int32 + +const ( + Defaults_RED Defaults_Color = 0 + Defaults_GREEN Defaults_Color = 1 + Defaults_BLUE Defaults_Color = 2 +) + +var Defaults_Color_name = map[int32]string{ + 0: "RED", + 1: "GREEN", + 2: "BLUE", +} +var Defaults_Color_value = map[string]int32{ + "RED": 0, + "GREEN": 1, + "BLUE": 2, +} + +func (x Defaults_Color) Enum() *Defaults_Color { + p := new(Defaults_Color) + *p = x + return p +} +func (x Defaults_Color) String() string { + return proto.EnumName(Defaults_Color_name, int32(x)) +} +func (x Defaults_Color) MarshalJSON() ([]byte, error) { + return json.Marshal(x.String()) +} +func (x *Defaults_Color) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Defaults_Color_value, data, "Defaults_Color") + if err != nil { + return err + } + *x = Defaults_Color(value) + return nil +} + +type RepeatedEnum_Color int32 + +const ( + RepeatedEnum_RED RepeatedEnum_Color = 1 +) + +var RepeatedEnum_Color_name = map[int32]string{ + 1: "RED", +} +var RepeatedEnum_Color_value = map[string]int32{ + "RED": 1, +} + +func (x RepeatedEnum_Color) Enum() *RepeatedEnum_Color { + p := new(RepeatedEnum_Color) + *p = x + return p +} +func (x RepeatedEnum_Color) String() string { + return proto.EnumName(RepeatedEnum_Color_name, int32(x)) +} +func (x RepeatedEnum_Color) MarshalJSON() ([]byte, error) { + return json.Marshal(x.String()) +} +func (x *RepeatedEnum_Color) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(RepeatedEnum_Color_value, data, "RepeatedEnum_Color") + if err != nil { + return err + } + *x = RepeatedEnum_Color(value) + return nil +} + +type GoEnum struct { + Foo *FOO `protobuf:"varint,1,req,name=foo,enum=testdata.FOO" json:"foo,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GoEnum) Reset() { *m = GoEnum{} } +func (m *GoEnum) String() string { return proto.CompactTextString(m) } +func (*GoEnum) ProtoMessage() {} + +func (m *GoEnum) GetFoo() FOO { + if m != nil && m.Foo != nil { + return *m.Foo + } + return 0 +} + +type GoTestField struct { + Label *string `protobuf:"bytes,1,req" json:"Label,omitempty"` + Type *string `protobuf:"bytes,2,req" json:"Type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GoTestField) Reset() { *m = GoTestField{} } +func (m *GoTestField) String() string { return proto.CompactTextString(m) } +func (*GoTestField) ProtoMessage() {} + +func (m *GoTestField) GetLabel() string { + if m != nil && m.Label != nil { + return *m.Label + } + return "" +} + +func (m *GoTestField) GetType() string { + if m != nil && m.Type != nil { + return *m.Type + } + return "" +} + +type GoTest struct { + Kind *GoTest_KIND `protobuf:"varint,1,req,enum=testdata.GoTest_KIND" json:"Kind,omitempty"` + Table *string `protobuf:"bytes,2,opt" json:"Table,omitempty"` + Param *int32 `protobuf:"varint,3,opt" json:"Param,omitempty"` + RequiredField *GoTestField `protobuf:"bytes,4,req" json:"RequiredField,omitempty"` + RepeatedField []*GoTestField `protobuf:"bytes,5,rep" json:"RepeatedField,omitempty"` + OptionalField *GoTestField `protobuf:"bytes,6,opt" json:"OptionalField,omitempty"` + F_BoolRequired *bool `protobuf:"varint,10,req,name=F_Bool_required" json:"F_Bool_required,omitempty"` + F_Int32Required *int32 `protobuf:"varint,11,req,name=F_Int32_required" json:"F_Int32_required,omitempty"` + F_Int64Required *int64 `protobuf:"varint,12,req,name=F_Int64_required" json:"F_Int64_required,omitempty"` + F_Fixed32Required *uint32 `protobuf:"fixed32,13,req,name=F_Fixed32_required" json:"F_Fixed32_required,omitempty"` + F_Fixed64Required *uint64 `protobuf:"fixed64,14,req,name=F_Fixed64_required" json:"F_Fixed64_required,omitempty"` + F_Uint32Required *uint32 `protobuf:"varint,15,req,name=F_Uint32_required" json:"F_Uint32_required,omitempty"` + F_Uint64Required *uint64 `protobuf:"varint,16,req,name=F_Uint64_required" json:"F_Uint64_required,omitempty"` + F_FloatRequired *float32 `protobuf:"fixed32,17,req,name=F_Float_required" json:"F_Float_required,omitempty"` + F_DoubleRequired *float64 `protobuf:"fixed64,18,req,name=F_Double_required" json:"F_Double_required,omitempty"` + F_StringRequired *string `protobuf:"bytes,19,req,name=F_String_required" json:"F_String_required,omitempty"` + F_BytesRequired []byte `protobuf:"bytes,101,req,name=F_Bytes_required" json:"F_Bytes_required,omitempty"` + F_Sint32Required *int32 `protobuf:"zigzag32,102,req,name=F_Sint32_required" json:"F_Sint32_required,omitempty"` + F_Sint64Required *int64 `protobuf:"zigzag64,103,req,name=F_Sint64_required" json:"F_Sint64_required,omitempty"` + F_BoolRepeated []bool `protobuf:"varint,20,rep,name=F_Bool_repeated" json:"F_Bool_repeated,omitempty"` + F_Int32Repeated []int32 `protobuf:"varint,21,rep,name=F_Int32_repeated" json:"F_Int32_repeated,omitempty"` + F_Int64Repeated []int64 `protobuf:"varint,22,rep,name=F_Int64_repeated" json:"F_Int64_repeated,omitempty"` + F_Fixed32Repeated []uint32 `protobuf:"fixed32,23,rep,name=F_Fixed32_repeated" json:"F_Fixed32_repeated,omitempty"` + F_Fixed64Repeated []uint64 `protobuf:"fixed64,24,rep,name=F_Fixed64_repeated" json:"F_Fixed64_repeated,omitempty"` + F_Uint32Repeated []uint32 `protobuf:"varint,25,rep,name=F_Uint32_repeated" json:"F_Uint32_repeated,omitempty"` + F_Uint64Repeated []uint64 `protobuf:"varint,26,rep,name=F_Uint64_repeated" json:"F_Uint64_repeated,omitempty"` + F_FloatRepeated []float32 `protobuf:"fixed32,27,rep,name=F_Float_repeated" json:"F_Float_repeated,omitempty"` + F_DoubleRepeated []float64 `protobuf:"fixed64,28,rep,name=F_Double_repeated" json:"F_Double_repeated,omitempty"` + F_StringRepeated []string `protobuf:"bytes,29,rep,name=F_String_repeated" json:"F_String_repeated,omitempty"` + F_BytesRepeated [][]byte `protobuf:"bytes,201,rep,name=F_Bytes_repeated" json:"F_Bytes_repeated,omitempty"` + F_Sint32Repeated []int32 `protobuf:"zigzag32,202,rep,name=F_Sint32_repeated" json:"F_Sint32_repeated,omitempty"` + F_Sint64Repeated []int64 `protobuf:"zigzag64,203,rep,name=F_Sint64_repeated" json:"F_Sint64_repeated,omitempty"` + F_BoolOptional *bool `protobuf:"varint,30,opt,name=F_Bool_optional" json:"F_Bool_optional,omitempty"` + F_Int32Optional *int32 `protobuf:"varint,31,opt,name=F_Int32_optional" json:"F_Int32_optional,omitempty"` + F_Int64Optional *int64 `protobuf:"varint,32,opt,name=F_Int64_optional" json:"F_Int64_optional,omitempty"` + F_Fixed32Optional *uint32 `protobuf:"fixed32,33,opt,name=F_Fixed32_optional" json:"F_Fixed32_optional,omitempty"` + F_Fixed64Optional *uint64 `protobuf:"fixed64,34,opt,name=F_Fixed64_optional" json:"F_Fixed64_optional,omitempty"` + F_Uint32Optional *uint32 `protobuf:"varint,35,opt,name=F_Uint32_optional" json:"F_Uint32_optional,omitempty"` + F_Uint64Optional *uint64 `protobuf:"varint,36,opt,name=F_Uint64_optional" json:"F_Uint64_optional,omitempty"` + F_FloatOptional *float32 `protobuf:"fixed32,37,opt,name=F_Float_optional" json:"F_Float_optional,omitempty"` + F_DoubleOptional *float64 `protobuf:"fixed64,38,opt,name=F_Double_optional" json:"F_Double_optional,omitempty"` + F_StringOptional *string `protobuf:"bytes,39,opt,name=F_String_optional" json:"F_String_optional,omitempty"` + F_BytesOptional []byte `protobuf:"bytes,301,opt,name=F_Bytes_optional" json:"F_Bytes_optional,omitempty"` + F_Sint32Optional *int32 `protobuf:"zigzag32,302,opt,name=F_Sint32_optional" json:"F_Sint32_optional,omitempty"` + F_Sint64Optional *int64 `protobuf:"zigzag64,303,opt,name=F_Sint64_optional" json:"F_Sint64_optional,omitempty"` + F_BoolDefaulted *bool `protobuf:"varint,40,opt,name=F_Bool_defaulted,def=1" json:"F_Bool_defaulted,omitempty"` + F_Int32Defaulted *int32 `protobuf:"varint,41,opt,name=F_Int32_defaulted,def=32" json:"F_Int32_defaulted,omitempty"` + F_Int64Defaulted *int64 `protobuf:"varint,42,opt,name=F_Int64_defaulted,def=64" json:"F_Int64_defaulted,omitempty"` + F_Fixed32Defaulted *uint32 `protobuf:"fixed32,43,opt,name=F_Fixed32_defaulted,def=320" json:"F_Fixed32_defaulted,omitempty"` + F_Fixed64Defaulted *uint64 `protobuf:"fixed64,44,opt,name=F_Fixed64_defaulted,def=640" json:"F_Fixed64_defaulted,omitempty"` + F_Uint32Defaulted *uint32 `protobuf:"varint,45,opt,name=F_Uint32_defaulted,def=3200" json:"F_Uint32_defaulted,omitempty"` + F_Uint64Defaulted *uint64 `protobuf:"varint,46,opt,name=F_Uint64_defaulted,def=6400" json:"F_Uint64_defaulted,omitempty"` + F_FloatDefaulted *float32 `protobuf:"fixed32,47,opt,name=F_Float_defaulted,def=314159" json:"F_Float_defaulted,omitempty"` + F_DoubleDefaulted *float64 `protobuf:"fixed64,48,opt,name=F_Double_defaulted,def=271828" json:"F_Double_defaulted,omitempty"` + F_StringDefaulted *string `protobuf:"bytes,49,opt,name=F_String_defaulted,def=hello, \"world!\"\n" json:"F_String_defaulted,omitempty"` + F_BytesDefaulted []byte `protobuf:"bytes,401,opt,name=F_Bytes_defaulted,def=Bignose" json:"F_Bytes_defaulted,omitempty"` + F_Sint32Defaulted *int32 `protobuf:"zigzag32,402,opt,name=F_Sint32_defaulted,def=-32" json:"F_Sint32_defaulted,omitempty"` + F_Sint64Defaulted *int64 `protobuf:"zigzag64,403,opt,name=F_Sint64_defaulted,def=-64" json:"F_Sint64_defaulted,omitempty"` + F_BoolRepeatedPacked []bool `protobuf:"varint,50,rep,packed,name=F_Bool_repeated_packed" json:"F_Bool_repeated_packed,omitempty"` + F_Int32RepeatedPacked []int32 `protobuf:"varint,51,rep,packed,name=F_Int32_repeated_packed" json:"F_Int32_repeated_packed,omitempty"` + F_Int64RepeatedPacked []int64 `protobuf:"varint,52,rep,packed,name=F_Int64_repeated_packed" json:"F_Int64_repeated_packed,omitempty"` + F_Fixed32RepeatedPacked []uint32 `protobuf:"fixed32,53,rep,packed,name=F_Fixed32_repeated_packed" json:"F_Fixed32_repeated_packed,omitempty"` + F_Fixed64RepeatedPacked []uint64 `protobuf:"fixed64,54,rep,packed,name=F_Fixed64_repeated_packed" json:"F_Fixed64_repeated_packed,omitempty"` + F_Uint32RepeatedPacked []uint32 `protobuf:"varint,55,rep,packed,name=F_Uint32_repeated_packed" json:"F_Uint32_repeated_packed,omitempty"` + F_Uint64RepeatedPacked []uint64 `protobuf:"varint,56,rep,packed,name=F_Uint64_repeated_packed" json:"F_Uint64_repeated_packed,omitempty"` + F_FloatRepeatedPacked []float32 `protobuf:"fixed32,57,rep,packed,name=F_Float_repeated_packed" json:"F_Float_repeated_packed,omitempty"` + F_DoubleRepeatedPacked []float64 `protobuf:"fixed64,58,rep,packed,name=F_Double_repeated_packed" json:"F_Double_repeated_packed,omitempty"` + F_Sint32RepeatedPacked []int32 `protobuf:"zigzag32,502,rep,packed,name=F_Sint32_repeated_packed" json:"F_Sint32_repeated_packed,omitempty"` + F_Sint64RepeatedPacked []int64 `protobuf:"zigzag64,503,rep,packed,name=F_Sint64_repeated_packed" json:"F_Sint64_repeated_packed,omitempty"` + Requiredgroup *GoTest_RequiredGroup `protobuf:"group,70,req,name=RequiredGroup" json:"requiredgroup,omitempty"` + Repeatedgroup []*GoTest_RepeatedGroup `protobuf:"group,80,rep,name=RepeatedGroup" json:"repeatedgroup,omitempty"` + Optionalgroup *GoTest_OptionalGroup `protobuf:"group,90,opt,name=OptionalGroup" json:"optionalgroup,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GoTest) Reset() { *m = GoTest{} } +func (m *GoTest) String() string { return proto.CompactTextString(m) } +func (*GoTest) ProtoMessage() {} + +const Default_GoTest_F_BoolDefaulted bool = true +const Default_GoTest_F_Int32Defaulted int32 = 32 +const Default_GoTest_F_Int64Defaulted int64 = 64 +const Default_GoTest_F_Fixed32Defaulted uint32 = 320 +const Default_GoTest_F_Fixed64Defaulted uint64 = 640 +const Default_GoTest_F_Uint32Defaulted uint32 = 3200 +const Default_GoTest_F_Uint64Defaulted uint64 = 6400 +const Default_GoTest_F_FloatDefaulted float32 = 314159 +const Default_GoTest_F_DoubleDefaulted float64 = 271828 +const Default_GoTest_F_StringDefaulted string = "hello, \"world!\"\n" + +var Default_GoTest_F_BytesDefaulted []byte = []byte("Bignose") + +const Default_GoTest_F_Sint32Defaulted int32 = -32 +const Default_GoTest_F_Sint64Defaulted int64 = -64 + +func (m *GoTest) GetKind() GoTest_KIND { + if m != nil && m.Kind != nil { + return *m.Kind + } + return 0 +} + +func (m *GoTest) GetTable() string { + if m != nil && m.Table != nil { + return *m.Table + } + return "" +} + +func (m *GoTest) GetParam() int32 { + if m != nil && m.Param != nil { + return *m.Param + } + return 0 +} + +func (m *GoTest) GetRequiredField() *GoTestField { + if m != nil { + return m.RequiredField + } + return nil +} + +func (m *GoTest) GetRepeatedField() []*GoTestField { + if m != nil { + return m.RepeatedField + } + return nil +} + +func (m *GoTest) GetOptionalField() *GoTestField { + if m != nil { + return m.OptionalField + } + return nil +} + +func (m *GoTest) GetF_BoolRequired() bool { + if m != nil && m.F_BoolRequired != nil { + return *m.F_BoolRequired + } + return false +} + +func (m *GoTest) GetF_Int32Required() int32 { + if m != nil && m.F_Int32Required != nil { + return *m.F_Int32Required + } + return 0 +} + +func (m *GoTest) GetF_Int64Required() int64 { + if m != nil && m.F_Int64Required != nil { + return *m.F_Int64Required + } + return 0 +} + +func (m *GoTest) GetF_Fixed32Required() uint32 { + if m != nil && m.F_Fixed32Required != nil { + return *m.F_Fixed32Required + } + return 0 +} + +func (m *GoTest) GetF_Fixed64Required() uint64 { + if m != nil && m.F_Fixed64Required != nil { + return *m.F_Fixed64Required + } + return 0 +} + +func (m *GoTest) GetF_Uint32Required() uint32 { + if m != nil && m.F_Uint32Required != nil { + return *m.F_Uint32Required + } + return 0 +} + +func (m *GoTest) GetF_Uint64Required() uint64 { + if m != nil && m.F_Uint64Required != nil { + return *m.F_Uint64Required + } + return 0 +} + +func (m *GoTest) GetF_FloatRequired() float32 { + if m != nil && m.F_FloatRequired != nil { + return *m.F_FloatRequired + } + return 0 +} + +func (m *GoTest) GetF_DoubleRequired() float64 { + if m != nil && m.F_DoubleRequired != nil { + return *m.F_DoubleRequired + } + return 0 +} + +func (m *GoTest) GetF_StringRequired() string { + if m != nil && m.F_StringRequired != nil { + return *m.F_StringRequired + } + return "" +} + +func (m *GoTest) GetF_BytesRequired() []byte { + if m != nil { + return m.F_BytesRequired + } + return nil +} + +func (m *GoTest) GetF_Sint32Required() int32 { + if m != nil && m.F_Sint32Required != nil { + return *m.F_Sint32Required + } + return 0 +} + +func (m *GoTest) GetF_Sint64Required() int64 { + if m != nil && m.F_Sint64Required != nil { + return *m.F_Sint64Required + } + return 0 +} + +func (m *GoTest) GetF_BoolRepeated() []bool { + if m != nil { + return m.F_BoolRepeated + } + return nil +} + +func (m *GoTest) GetF_Int32Repeated() []int32 { + if m != nil { + return m.F_Int32Repeated + } + return nil +} + +func (m *GoTest) GetF_Int64Repeated() []int64 { + if m != nil { + return m.F_Int64Repeated + } + return nil +} + +func (m *GoTest) GetF_Fixed32Repeated() []uint32 { + if m != nil { + return m.F_Fixed32Repeated + } + return nil +} + +func (m *GoTest) GetF_Fixed64Repeated() []uint64 { + if m != nil { + return m.F_Fixed64Repeated + } + return nil +} + +func (m *GoTest) GetF_Uint32Repeated() []uint32 { + if m != nil { + return m.F_Uint32Repeated + } + return nil +} + +func (m *GoTest) GetF_Uint64Repeated() []uint64 { + if m != nil { + return m.F_Uint64Repeated + } + return nil +} + +func (m *GoTest) GetF_FloatRepeated() []float32 { + if m != nil { + return m.F_FloatRepeated + } + return nil +} + +func (m *GoTest) GetF_DoubleRepeated() []float64 { + if m != nil { + return m.F_DoubleRepeated + } + return nil +} + +func (m *GoTest) GetF_StringRepeated() []string { + if m != nil { + return m.F_StringRepeated + } + return nil +} + +func (m *GoTest) GetF_BytesRepeated() [][]byte { + if m != nil { + return m.F_BytesRepeated + } + return nil +} + +func (m *GoTest) GetF_Sint32Repeated() []int32 { + if m != nil { + return m.F_Sint32Repeated + } + return nil +} + +func (m *GoTest) GetF_Sint64Repeated() []int64 { + if m != nil { + return m.F_Sint64Repeated + } + return nil +} + +func (m *GoTest) GetF_BoolOptional() bool { + if m != nil && m.F_BoolOptional != nil { + return *m.F_BoolOptional + } + return false +} + +func (m *GoTest) GetF_Int32Optional() int32 { + if m != nil && m.F_Int32Optional != nil { + return *m.F_Int32Optional + } + return 0 +} + +func (m *GoTest) GetF_Int64Optional() int64 { + if m != nil && m.F_Int64Optional != nil { + return *m.F_Int64Optional + } + return 0 +} + +func (m *GoTest) GetF_Fixed32Optional() uint32 { + if m != nil && m.F_Fixed32Optional != nil { + return *m.F_Fixed32Optional + } + return 0 +} + +func (m *GoTest) GetF_Fixed64Optional() uint64 { + if m != nil && m.F_Fixed64Optional != nil { + return *m.F_Fixed64Optional + } + return 0 +} + +func (m *GoTest) GetF_Uint32Optional() uint32 { + if m != nil && m.F_Uint32Optional != nil { + return *m.F_Uint32Optional + } + return 0 +} + +func (m *GoTest) GetF_Uint64Optional() uint64 { + if m != nil && m.F_Uint64Optional != nil { + return *m.F_Uint64Optional + } + return 0 +} + +func (m *GoTest) GetF_FloatOptional() float32 { + if m != nil && m.F_FloatOptional != nil { + return *m.F_FloatOptional + } + return 0 +} + +func (m *GoTest) GetF_DoubleOptional() float64 { + if m != nil && m.F_DoubleOptional != nil { + return *m.F_DoubleOptional + } + return 0 +} + +func (m *GoTest) GetF_StringOptional() string { + if m != nil && m.F_StringOptional != nil { + return *m.F_StringOptional + } + return "" +} + +func (m *GoTest) GetF_BytesOptional() []byte { + if m != nil { + return m.F_BytesOptional + } + return nil +} + +func (m *GoTest) GetF_Sint32Optional() int32 { + if m != nil && m.F_Sint32Optional != nil { + return *m.F_Sint32Optional + } + return 0 +} + +func (m *GoTest) GetF_Sint64Optional() int64 { + if m != nil && m.F_Sint64Optional != nil { + return *m.F_Sint64Optional + } + return 0 +} + +func (m *GoTest) GetF_BoolDefaulted() bool { + if m != nil && m.F_BoolDefaulted != nil { + return *m.F_BoolDefaulted + } + return Default_GoTest_F_BoolDefaulted +} + +func (m *GoTest) GetF_Int32Defaulted() int32 { + if m != nil && m.F_Int32Defaulted != nil { + return *m.F_Int32Defaulted + } + return Default_GoTest_F_Int32Defaulted +} + +func (m *GoTest) GetF_Int64Defaulted() int64 { + if m != nil && m.F_Int64Defaulted != nil { + return *m.F_Int64Defaulted + } + return Default_GoTest_F_Int64Defaulted +} + +func (m *GoTest) GetF_Fixed32Defaulted() uint32 { + if m != nil && m.F_Fixed32Defaulted != nil { + return *m.F_Fixed32Defaulted + } + return Default_GoTest_F_Fixed32Defaulted +} + +func (m *GoTest) GetF_Fixed64Defaulted() uint64 { + if m != nil && m.F_Fixed64Defaulted != nil { + return *m.F_Fixed64Defaulted + } + return Default_GoTest_F_Fixed64Defaulted +} + +func (m *GoTest) GetF_Uint32Defaulted() uint32 { + if m != nil && m.F_Uint32Defaulted != nil { + return *m.F_Uint32Defaulted + } + return Default_GoTest_F_Uint32Defaulted +} + +func (m *GoTest) GetF_Uint64Defaulted() uint64 { + if m != nil && m.F_Uint64Defaulted != nil { + return *m.F_Uint64Defaulted + } + return Default_GoTest_F_Uint64Defaulted +} + +func (m *GoTest) GetF_FloatDefaulted() float32 { + if m != nil && m.F_FloatDefaulted != nil { + return *m.F_FloatDefaulted + } + return Default_GoTest_F_FloatDefaulted +} + +func (m *GoTest) GetF_DoubleDefaulted() float64 { + if m != nil && m.F_DoubleDefaulted != nil { + return *m.F_DoubleDefaulted + } + return Default_GoTest_F_DoubleDefaulted +} + +func (m *GoTest) GetF_StringDefaulted() string { + if m != nil && m.F_StringDefaulted != nil { + return *m.F_StringDefaulted + } + return Default_GoTest_F_StringDefaulted +} + +func (m *GoTest) GetF_BytesDefaulted() []byte { + if m != nil && m.F_BytesDefaulted != nil { + return m.F_BytesDefaulted + } + return append([]byte(nil), Default_GoTest_F_BytesDefaulted...) +} + +func (m *GoTest) GetF_Sint32Defaulted() int32 { + if m != nil && m.F_Sint32Defaulted != nil { + return *m.F_Sint32Defaulted + } + return Default_GoTest_F_Sint32Defaulted +} + +func (m *GoTest) GetF_Sint64Defaulted() int64 { + if m != nil && m.F_Sint64Defaulted != nil { + return *m.F_Sint64Defaulted + } + return Default_GoTest_F_Sint64Defaulted +} + +func (m *GoTest) GetF_BoolRepeatedPacked() []bool { + if m != nil { + return m.F_BoolRepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_Int32RepeatedPacked() []int32 { + if m != nil { + return m.F_Int32RepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_Int64RepeatedPacked() []int64 { + if m != nil { + return m.F_Int64RepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_Fixed32RepeatedPacked() []uint32 { + if m != nil { + return m.F_Fixed32RepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_Fixed64RepeatedPacked() []uint64 { + if m != nil { + return m.F_Fixed64RepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_Uint32RepeatedPacked() []uint32 { + if m != nil { + return m.F_Uint32RepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_Uint64RepeatedPacked() []uint64 { + if m != nil { + return m.F_Uint64RepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_FloatRepeatedPacked() []float32 { + if m != nil { + return m.F_FloatRepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_DoubleRepeatedPacked() []float64 { + if m != nil { + return m.F_DoubleRepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_Sint32RepeatedPacked() []int32 { + if m != nil { + return m.F_Sint32RepeatedPacked + } + return nil +} + +func (m *GoTest) GetF_Sint64RepeatedPacked() []int64 { + if m != nil { + return m.F_Sint64RepeatedPacked + } + return nil +} + +func (m *GoTest) GetRequiredgroup() *GoTest_RequiredGroup { + if m != nil { + return m.Requiredgroup + } + return nil +} + +func (m *GoTest) GetRepeatedgroup() []*GoTest_RepeatedGroup { + if m != nil { + return m.Repeatedgroup + } + return nil +} + +func (m *GoTest) GetOptionalgroup() *GoTest_OptionalGroup { + if m != nil { + return m.Optionalgroup + } + return nil +} + +type GoTest_RequiredGroup struct { + RequiredField *string `protobuf:"bytes,71,req" json:"RequiredField,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GoTest_RequiredGroup) Reset() { *m = GoTest_RequiredGroup{} } + +func (m *GoTest_RequiredGroup) GetRequiredField() string { + if m != nil && m.RequiredField != nil { + return *m.RequiredField + } + return "" +} + +type GoTest_RepeatedGroup struct { + RequiredField *string `protobuf:"bytes,81,req" json:"RequiredField,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GoTest_RepeatedGroup) Reset() { *m = GoTest_RepeatedGroup{} } + +func (m *GoTest_RepeatedGroup) GetRequiredField() string { + if m != nil && m.RequiredField != nil { + return *m.RequiredField + } + return "" +} + +type GoTest_OptionalGroup struct { + RequiredField *string `protobuf:"bytes,91,req" json:"RequiredField,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GoTest_OptionalGroup) Reset() { *m = GoTest_OptionalGroup{} } + +func (m *GoTest_OptionalGroup) GetRequiredField() string { + if m != nil && m.RequiredField != nil { + return *m.RequiredField + } + return "" +} + +type GoSkipTest struct { + SkipInt32 *int32 `protobuf:"varint,11,req,name=skip_int32" json:"skip_int32,omitempty"` + SkipFixed32 *uint32 `protobuf:"fixed32,12,req,name=skip_fixed32" json:"skip_fixed32,omitempty"` + SkipFixed64 *uint64 `protobuf:"fixed64,13,req,name=skip_fixed64" json:"skip_fixed64,omitempty"` + SkipString *string `protobuf:"bytes,14,req,name=skip_string" json:"skip_string,omitempty"` + Skipgroup *GoSkipTest_SkipGroup `protobuf:"group,15,req,name=SkipGroup" json:"skipgroup,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GoSkipTest) Reset() { *m = GoSkipTest{} } +func (m *GoSkipTest) String() string { return proto.CompactTextString(m) } +func (*GoSkipTest) ProtoMessage() {} + +func (m *GoSkipTest) GetSkipInt32() int32 { + if m != nil && m.SkipInt32 != nil { + return *m.SkipInt32 + } + return 0 +} + +func (m *GoSkipTest) GetSkipFixed32() uint32 { + if m != nil && m.SkipFixed32 != nil { + return *m.SkipFixed32 + } + return 0 +} + +func (m *GoSkipTest) GetSkipFixed64() uint64 { + if m != nil && m.SkipFixed64 != nil { + return *m.SkipFixed64 + } + return 0 +} + +func (m *GoSkipTest) GetSkipString() string { + if m != nil && m.SkipString != nil { + return *m.SkipString + } + return "" +} + +func (m *GoSkipTest) GetSkipgroup() *GoSkipTest_SkipGroup { + if m != nil { + return m.Skipgroup + } + return nil +} + +type GoSkipTest_SkipGroup struct { + GroupInt32 *int32 `protobuf:"varint,16,req,name=group_int32" json:"group_int32,omitempty"` + GroupString *string `protobuf:"bytes,17,req,name=group_string" json:"group_string,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GoSkipTest_SkipGroup) Reset() { *m = GoSkipTest_SkipGroup{} } + +func (m *GoSkipTest_SkipGroup) GetGroupInt32() int32 { + if m != nil && m.GroupInt32 != nil { + return *m.GroupInt32 + } + return 0 +} + +func (m *GoSkipTest_SkipGroup) GetGroupString() string { + if m != nil && m.GroupString != nil { + return *m.GroupString + } + return "" +} + +type NonPackedTest struct { + A []int32 `protobuf:"varint,1,rep,name=a" json:"a,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NonPackedTest) Reset() { *m = NonPackedTest{} } +func (m *NonPackedTest) String() string { return proto.CompactTextString(m) } +func (*NonPackedTest) ProtoMessage() {} + +func (m *NonPackedTest) GetA() []int32 { + if m != nil { + return m.A + } + return nil +} + +type PackedTest struct { + B []int32 `protobuf:"varint,1,rep,packed,name=b" json:"b,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PackedTest) Reset() { *m = PackedTest{} } +func (m *PackedTest) String() string { return proto.CompactTextString(m) } +func (*PackedTest) ProtoMessage() {} + +func (m *PackedTest) GetB() []int32 { + if m != nil { + return m.B + } + return nil +} + +type MaxTag struct { + LastField *string `protobuf:"bytes,536870911,opt,name=last_field" json:"last_field,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MaxTag) Reset() { *m = MaxTag{} } +func (m *MaxTag) String() string { return proto.CompactTextString(m) } +func (*MaxTag) ProtoMessage() {} + +func (m *MaxTag) GetLastField() string { + if m != nil && m.LastField != nil { + return *m.LastField + } + return "" +} + +type OldMessage struct { + Nested *OldMessage_Nested `protobuf:"bytes,1,opt,name=nested" json:"nested,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OldMessage) Reset() { *m = OldMessage{} } +func (m *OldMessage) String() string { return proto.CompactTextString(m) } +func (*OldMessage) ProtoMessage() {} + +func (m *OldMessage) GetNested() *OldMessage_Nested { + if m != nil { + return m.Nested + } + return nil +} + +type OldMessage_Nested struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OldMessage_Nested) Reset() { *m = OldMessage_Nested{} } +func (m *OldMessage_Nested) String() string { return proto.CompactTextString(m) } +func (*OldMessage_Nested) ProtoMessage() {} + +func (m *OldMessage_Nested) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +type NewMessage struct { + Nested *NewMessage_Nested `protobuf:"bytes,1,opt,name=nested" json:"nested,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NewMessage) Reset() { *m = NewMessage{} } +func (m *NewMessage) String() string { return proto.CompactTextString(m) } +func (*NewMessage) ProtoMessage() {} + +func (m *NewMessage) GetNested() *NewMessage_Nested { + if m != nil { + return m.Nested + } + return nil +} + +type NewMessage_Nested struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + FoodGroup *string `protobuf:"bytes,2,opt,name=food_group" json:"food_group,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NewMessage_Nested) Reset() { *m = NewMessage_Nested{} } +func (m *NewMessage_Nested) String() string { return proto.CompactTextString(m) } +func (*NewMessage_Nested) ProtoMessage() {} + +func (m *NewMessage_Nested) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *NewMessage_Nested) GetFoodGroup() string { + if m != nil && m.FoodGroup != nil { + return *m.FoodGroup + } + return "" +} + +type InnerMessage struct { + Host *string `protobuf:"bytes,1,req,name=host" json:"host,omitempty"` + Port *int32 `protobuf:"varint,2,opt,name=port,def=4000" json:"port,omitempty"` + Connected *bool `protobuf:"varint,3,opt,name=connected" json:"connected,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *InnerMessage) Reset() { *m = InnerMessage{} } +func (m *InnerMessage) String() string { return proto.CompactTextString(m) } +func (*InnerMessage) ProtoMessage() {} + +const Default_InnerMessage_Port int32 = 4000 + +func (m *InnerMessage) GetHost() string { + if m != nil && m.Host != nil { + return *m.Host + } + return "" +} + +func (m *InnerMessage) GetPort() int32 { + if m != nil && m.Port != nil { + return *m.Port + } + return Default_InnerMessage_Port +} + +func (m *InnerMessage) GetConnected() bool { + if m != nil && m.Connected != nil { + return *m.Connected + } + return false +} + +type OtherMessage struct { + Key *int64 `protobuf:"varint,1,opt,name=key" json:"key,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` + Weight *float32 `protobuf:"fixed32,3,opt,name=weight" json:"weight,omitempty"` + Inner *InnerMessage `protobuf:"bytes,4,opt,name=inner" json:"inner,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OtherMessage) Reset() { *m = OtherMessage{} } +func (m *OtherMessage) String() string { return proto.CompactTextString(m) } +func (*OtherMessage) ProtoMessage() {} + +func (m *OtherMessage) GetKey() int64 { + if m != nil && m.Key != nil { + return *m.Key + } + return 0 +} + +func (m *OtherMessage) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +func (m *OtherMessage) GetWeight() float32 { + if m != nil && m.Weight != nil { + return *m.Weight + } + return 0 +} + +func (m *OtherMessage) GetInner() *InnerMessage { + if m != nil { + return m.Inner + } + return nil +} + +type MyMessage struct { + Count *int32 `protobuf:"varint,1,req,name=count" json:"count,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + Quote *string `protobuf:"bytes,3,opt,name=quote" json:"quote,omitempty"` + Pet []string `protobuf:"bytes,4,rep,name=pet" json:"pet,omitempty"` + Inner *InnerMessage `protobuf:"bytes,5,opt,name=inner" json:"inner,omitempty"` + Others []*OtherMessage `protobuf:"bytes,6,rep,name=others" json:"others,omitempty"` + Bikeshed *MyMessage_Color `protobuf:"varint,7,opt,name=bikeshed,enum=testdata.MyMessage_Color" json:"bikeshed,omitempty"` + Somegroup *MyMessage_SomeGroup `protobuf:"group,8,opt,name=SomeGroup" json:"somegroup,omitempty"` + RepBytes [][]byte `protobuf:"bytes,10,rep,name=rep_bytes" json:"rep_bytes,omitempty"` + Bigfloat *float64 `protobuf:"fixed64,11,opt,name=bigfloat" json:"bigfloat,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MyMessage) Reset() { *m = MyMessage{} } +func (m *MyMessage) String() string { return proto.CompactTextString(m) } +func (*MyMessage) ProtoMessage() {} + +var extRange_MyMessage = []proto.ExtensionRange{ + {100, 536870911}, +} + +func (*MyMessage) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MyMessage +} +func (m *MyMessage) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +func (m *MyMessage) GetCount() int32 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +func (m *MyMessage) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *MyMessage) GetQuote() string { + if m != nil && m.Quote != nil { + return *m.Quote + } + return "" +} + +func (m *MyMessage) GetPet() []string { + if m != nil { + return m.Pet + } + return nil +} + +func (m *MyMessage) GetInner() *InnerMessage { + if m != nil { + return m.Inner + } + return nil +} + +func (m *MyMessage) GetOthers() []*OtherMessage { + if m != nil { + return m.Others + } + return nil +} + +func (m *MyMessage) GetBikeshed() MyMessage_Color { + if m != nil && m.Bikeshed != nil { + return *m.Bikeshed + } + return 0 +} + +func (m *MyMessage) GetSomegroup() *MyMessage_SomeGroup { + if m != nil { + return m.Somegroup + } + return nil +} + +func (m *MyMessage) GetRepBytes() [][]byte { + if m != nil { + return m.RepBytes + } + return nil +} + +func (m *MyMessage) GetBigfloat() float64 { + if m != nil && m.Bigfloat != nil { + return *m.Bigfloat + } + return 0 +} + +type MyMessage_SomeGroup struct { + GroupField *int32 `protobuf:"varint,9,opt,name=group_field" json:"group_field,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MyMessage_SomeGroup) Reset() { *m = MyMessage_SomeGroup{} } + +func (m *MyMessage_SomeGroup) GetGroupField() int32 { + if m != nil && m.GroupField != nil { + return *m.GroupField + } + return 0 +} + +type Ext struct { + Data *string `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Ext) Reset() { *m = Ext{} } +func (m *Ext) String() string { return proto.CompactTextString(m) } +func (*Ext) ProtoMessage() {} + +func (m *Ext) GetData() string { + if m != nil && m.Data != nil { + return *m.Data + } + return "" +} + +var E_Ext_More = &proto.ExtensionDesc{ + ExtendedType: (*MyMessage)(nil), + ExtensionType: (*Ext)(nil), + Field: 103, + Name: "testdata.Ext.more", + Tag: "bytes,103,opt,name=more", +} + +var E_Ext_Text = &proto.ExtensionDesc{ + ExtendedType: (*MyMessage)(nil), + ExtensionType: (*string)(nil), + Field: 104, + Name: "testdata.Ext.text", + Tag: "bytes,104,opt,name=text", +} + +var E_Ext_Number = &proto.ExtensionDesc{ + ExtendedType: (*MyMessage)(nil), + ExtensionType: (*int32)(nil), + Field: 105, + Name: "testdata.Ext.number", + Tag: "varint,105,opt,name=number", +} + +type MessageList struct { + Message []*MessageList_Message `protobuf:"group,1,rep" json:"message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MessageList) Reset() { *m = MessageList{} } +func (m *MessageList) String() string { return proto.CompactTextString(m) } +func (*MessageList) ProtoMessage() {} + +func (m *MessageList) GetMessage() []*MessageList_Message { + if m != nil { + return m.Message + } + return nil +} + +type MessageList_Message struct { + Name *string `protobuf:"bytes,2,req,name=name" json:"name,omitempty"` + Count *int32 `protobuf:"varint,3,req,name=count" json:"count,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MessageList_Message) Reset() { *m = MessageList_Message{} } + +func (m *MessageList_Message) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *MessageList_Message) GetCount() int32 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +type Strings struct { + StringField *string `protobuf:"bytes,1,opt,name=string_field" json:"string_field,omitempty"` + BytesField []byte `protobuf:"bytes,2,opt,name=bytes_field" json:"bytes_field,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Strings) Reset() { *m = Strings{} } +func (m *Strings) String() string { return proto.CompactTextString(m) } +func (*Strings) ProtoMessage() {} + +func (m *Strings) GetStringField() string { + if m != nil && m.StringField != nil { + return *m.StringField + } + return "" +} + +func (m *Strings) GetBytesField() []byte { + if m != nil { + return m.BytesField + } + return nil +} + +type Defaults struct { + F_Bool *bool `protobuf:"varint,1,opt,def=1" json:"F_Bool,omitempty"` + F_Int32 *int32 `protobuf:"varint,2,opt,def=32" json:"F_Int32,omitempty"` + F_Int64 *int64 `protobuf:"varint,3,opt,def=64" json:"F_Int64,omitempty"` + F_Fixed32 *uint32 `protobuf:"fixed32,4,opt,def=320" json:"F_Fixed32,omitempty"` + F_Fixed64 *uint64 `protobuf:"fixed64,5,opt,def=640" json:"F_Fixed64,omitempty"` + F_Uint32 *uint32 `protobuf:"varint,6,opt,def=3200" json:"F_Uint32,omitempty"` + F_Uint64 *uint64 `protobuf:"varint,7,opt,def=6400" json:"F_Uint64,omitempty"` + F_Float *float32 `protobuf:"fixed32,8,opt,def=314159" json:"F_Float,omitempty"` + F_Double *float64 `protobuf:"fixed64,9,opt,def=271828" json:"F_Double,omitempty"` + F_String *string `protobuf:"bytes,10,opt,def=hello, \"world!\"\n" json:"F_String,omitempty"` + F_Bytes []byte `protobuf:"bytes,11,opt,def=Bignose" json:"F_Bytes,omitempty"` + F_Sint32 *int32 `protobuf:"zigzag32,12,opt,def=-32" json:"F_Sint32,omitempty"` + F_Sint64 *int64 `protobuf:"zigzag64,13,opt,def=-64" json:"F_Sint64,omitempty"` + F_Enum *Defaults_Color `protobuf:"varint,14,opt,enum=testdata.Defaults_Color,def=1" json:"F_Enum,omitempty"` + F_Pinf *float32 `protobuf:"fixed32,15,opt,def=inf" json:"F_Pinf,omitempty"` + F_Ninf *float32 `protobuf:"fixed32,16,opt,def=-inf" json:"F_Ninf,omitempty"` + F_Nan *float32 `protobuf:"fixed32,17,opt,def=nan" json:"F_Nan,omitempty"` + Sub *SubDefaults `protobuf:"bytes,18,opt,name=sub" json:"sub,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Defaults) Reset() { *m = Defaults{} } +func (m *Defaults) String() string { return proto.CompactTextString(m) } +func (*Defaults) ProtoMessage() {} + +const Default_Defaults_F_Bool bool = true +const Default_Defaults_F_Int32 int32 = 32 +const Default_Defaults_F_Int64 int64 = 64 +const Default_Defaults_F_Fixed32 uint32 = 320 +const Default_Defaults_F_Fixed64 uint64 = 640 +const Default_Defaults_F_Uint32 uint32 = 3200 +const Default_Defaults_F_Uint64 uint64 = 6400 +const Default_Defaults_F_Float float32 = 314159 +const Default_Defaults_F_Double float64 = 271828 +const Default_Defaults_F_String string = "hello, \"world!\"\n" + +var Default_Defaults_F_Bytes []byte = []byte("Bignose") + +const Default_Defaults_F_Sint32 int32 = -32 +const Default_Defaults_F_Sint64 int64 = -64 +const Default_Defaults_F_Enum Defaults_Color = Defaults_GREEN + +var Default_Defaults_F_Pinf float32 = float32(math.Inf(1)) +var Default_Defaults_F_Ninf float32 = float32(math.Inf(-1)) +var Default_Defaults_F_Nan float32 = float32(math.NaN()) + +func (m *Defaults) GetF_Bool() bool { + if m != nil && m.F_Bool != nil { + return *m.F_Bool + } + return Default_Defaults_F_Bool +} + +func (m *Defaults) GetF_Int32() int32 { + if m != nil && m.F_Int32 != nil { + return *m.F_Int32 + } + return Default_Defaults_F_Int32 +} + +func (m *Defaults) GetF_Int64() int64 { + if m != nil && m.F_Int64 != nil { + return *m.F_Int64 + } + return Default_Defaults_F_Int64 +} + +func (m *Defaults) GetF_Fixed32() uint32 { + if m != nil && m.F_Fixed32 != nil { + return *m.F_Fixed32 + } + return Default_Defaults_F_Fixed32 +} + +func (m *Defaults) GetF_Fixed64() uint64 { + if m != nil && m.F_Fixed64 != nil { + return *m.F_Fixed64 + } + return Default_Defaults_F_Fixed64 +} + +func (m *Defaults) GetF_Uint32() uint32 { + if m != nil && m.F_Uint32 != nil { + return *m.F_Uint32 + } + return Default_Defaults_F_Uint32 +} + +func (m *Defaults) GetF_Uint64() uint64 { + if m != nil && m.F_Uint64 != nil { + return *m.F_Uint64 + } + return Default_Defaults_F_Uint64 +} + +func (m *Defaults) GetF_Float() float32 { + if m != nil && m.F_Float != nil { + return *m.F_Float + } + return Default_Defaults_F_Float +} + +func (m *Defaults) GetF_Double() float64 { + if m != nil && m.F_Double != nil { + return *m.F_Double + } + return Default_Defaults_F_Double +} + +func (m *Defaults) GetF_String() string { + if m != nil && m.F_String != nil { + return *m.F_String + } + return Default_Defaults_F_String +} + +func (m *Defaults) GetF_Bytes() []byte { + if m != nil && m.F_Bytes != nil { + return m.F_Bytes + } + return append([]byte(nil), Default_Defaults_F_Bytes...) +} + +func (m *Defaults) GetF_Sint32() int32 { + if m != nil && m.F_Sint32 != nil { + return *m.F_Sint32 + } + return Default_Defaults_F_Sint32 +} + +func (m *Defaults) GetF_Sint64() int64 { + if m != nil && m.F_Sint64 != nil { + return *m.F_Sint64 + } + return Default_Defaults_F_Sint64 +} + +func (m *Defaults) GetF_Enum() Defaults_Color { + if m != nil && m.F_Enum != nil { + return *m.F_Enum + } + return Default_Defaults_F_Enum +} + +func (m *Defaults) GetF_Pinf() float32 { + if m != nil && m.F_Pinf != nil { + return *m.F_Pinf + } + return Default_Defaults_F_Pinf +} + +func (m *Defaults) GetF_Ninf() float32 { + if m != nil && m.F_Ninf != nil { + return *m.F_Ninf + } + return Default_Defaults_F_Ninf +} + +func (m *Defaults) GetF_Nan() float32 { + if m != nil && m.F_Nan != nil { + return *m.F_Nan + } + return Default_Defaults_F_Nan +} + +func (m *Defaults) GetSub() *SubDefaults { + if m != nil { + return m.Sub + } + return nil +} + +type SubDefaults struct { + N *int64 `protobuf:"varint,1,opt,name=n,def=7" json:"n,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SubDefaults) Reset() { *m = SubDefaults{} } +func (m *SubDefaults) String() string { return proto.CompactTextString(m) } +func (*SubDefaults) ProtoMessage() {} + +const Default_SubDefaults_N int64 = 7 + +func (m *SubDefaults) GetN() int64 { + if m != nil && m.N != nil { + return *m.N + } + return Default_SubDefaults_N +} + +type RepeatedEnum struct { + Color []RepeatedEnum_Color `protobuf:"varint,1,rep,name=color,enum=testdata.RepeatedEnum_Color" json:"color,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *RepeatedEnum) Reset() { *m = RepeatedEnum{} } +func (m *RepeatedEnum) String() string { return proto.CompactTextString(m) } +func (*RepeatedEnum) ProtoMessage() {} + +func (m *RepeatedEnum) GetColor() []RepeatedEnum_Color { + if m != nil { + return m.Color + } + return nil +} + +type MoreRepeated struct { + Bools []bool `protobuf:"varint,1,rep,name=bools" json:"bools,omitempty"` + BoolsPacked []bool `protobuf:"varint,2,rep,packed,name=bools_packed" json:"bools_packed,omitempty"` + Ints []int32 `protobuf:"varint,3,rep,name=ints" json:"ints,omitempty"` + IntsPacked []int32 `protobuf:"varint,4,rep,packed,name=ints_packed" json:"ints_packed,omitempty"` + Strings []string `protobuf:"bytes,5,rep,name=strings" json:"strings,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MoreRepeated) Reset() { *m = MoreRepeated{} } +func (m *MoreRepeated) String() string { return proto.CompactTextString(m) } +func (*MoreRepeated) ProtoMessage() {} + +func (m *MoreRepeated) GetBools() []bool { + if m != nil { + return m.Bools + } + return nil +} + +func (m *MoreRepeated) GetBoolsPacked() []bool { + if m != nil { + return m.BoolsPacked + } + return nil +} + +func (m *MoreRepeated) GetInts() []int32 { + if m != nil { + return m.Ints + } + return nil +} + +func (m *MoreRepeated) GetIntsPacked() []int32 { + if m != nil { + return m.IntsPacked + } + return nil +} + +func (m *MoreRepeated) GetStrings() []string { + if m != nil { + return m.Strings + } + return nil +} + +type GroupOld struct { + G *GroupOld_G `protobuf:"group,1,opt" json:"g,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GroupOld) Reset() { *m = GroupOld{} } +func (m *GroupOld) String() string { return proto.CompactTextString(m) } +func (*GroupOld) ProtoMessage() {} + +func (m *GroupOld) GetG() *GroupOld_G { + if m != nil { + return m.G + } + return nil +} + +type GroupOld_G struct { + X *int32 `protobuf:"varint,2,opt,name=x" json:"x,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GroupOld_G) Reset() { *m = GroupOld_G{} } + +func (m *GroupOld_G) GetX() int32 { + if m != nil && m.X != nil { + return *m.X + } + return 0 +} + +type GroupNew struct { + G *GroupNew_G `protobuf:"group,1,opt" json:"g,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GroupNew) Reset() { *m = GroupNew{} } +func (m *GroupNew) String() string { return proto.CompactTextString(m) } +func (*GroupNew) ProtoMessage() {} + +func (m *GroupNew) GetG() *GroupNew_G { + if m != nil { + return m.G + } + return nil +} + +type GroupNew_G struct { + X *int32 `protobuf:"varint,2,opt,name=x" json:"x,omitempty"` + Y *int32 `protobuf:"varint,3,opt,name=y" json:"y,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GroupNew_G) Reset() { *m = GroupNew_G{} } + +func (m *GroupNew_G) GetX() int32 { + if m != nil && m.X != nil { + return *m.X + } + return 0 +} + +func (m *GroupNew_G) GetY() int32 { + if m != nil && m.Y != nil { + return *m.Y + } + return 0 +} + +var E_Greeting = &proto.ExtensionDesc{ + ExtendedType: (*MyMessage)(nil), + ExtensionType: ([]string)(nil), + Field: 106, + Name: "testdata.greeting", + Tag: "bytes,106,rep,name=greeting", +} + +func init() { + proto.RegisterEnum("testdata.FOO", FOO_name, FOO_value) + proto.RegisterEnum("testdata.GoTest_KIND", GoTest_KIND_name, GoTest_KIND_value) + proto.RegisterEnum("testdata.MyMessage_Color", MyMessage_Color_name, MyMessage_Color_value) + proto.RegisterEnum("testdata.Defaults_Color", Defaults_Color_name, Defaults_Color_value) + proto.RegisterEnum("testdata.RepeatedEnum_Color", RepeatedEnum_Color_name, RepeatedEnum_Color_value) + proto.RegisterExtension(E_Ext_More) + proto.RegisterExtension(E_Ext_Text) + proto.RegisterExtension(E_Ext_Number) + proto.RegisterExtension(E_Greeting) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata/test.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata/test.proto new file mode 100644 index 0000000000000000000000000000000000000000..3d1cbb675d50513b90f47fd544b9b39e6a418045 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata/test.proto @@ -0,0 +1,494 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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. + +// A feature-rich test file for the protocol compiler and libraries. + +syntax = "proto2"; + +package testdata; + +enum FOO { FOO1 = 1; }; + +message GoEnum { + required FOO foo = 1; +} + +message GoTestField { + required string Label = 1; + required string Type = 2; +} + +message GoTest { + // An enum, for completeness. + enum KIND { + VOID = 0; + + // Basic types + BOOL = 1; + BYTES = 2; + FINGERPRINT = 3; + FLOAT = 4; + INT = 5; + STRING = 6; + TIME = 7; + + // Groupings + TUPLE = 8; + ARRAY = 9; + MAP = 10; + + // Table types + TABLE = 11; + + // Functions + FUNCTION = 12; // last tag + }; + + // Some typical parameters + required KIND Kind = 1; + optional string Table = 2; + optional int32 Param = 3; + + // Required, repeated and optional foreign fields. + required GoTestField RequiredField = 4; + repeated GoTestField RepeatedField = 5; + optional GoTestField OptionalField = 6; + + // Required fields of all basic types + required bool F_Bool_required = 10; + required int32 F_Int32_required = 11; + required int64 F_Int64_required = 12; + required fixed32 F_Fixed32_required = 13; + required fixed64 F_Fixed64_required = 14; + required uint32 F_Uint32_required = 15; + required uint64 F_Uint64_required = 16; + required float F_Float_required = 17; + required double F_Double_required = 18; + required string F_String_required = 19; + required bytes F_Bytes_required = 101; + required sint32 F_Sint32_required = 102; + required sint64 F_Sint64_required = 103; + + // Repeated fields of all basic types + repeated bool F_Bool_repeated = 20; + repeated int32 F_Int32_repeated = 21; + repeated int64 F_Int64_repeated = 22; + repeated fixed32 F_Fixed32_repeated = 23; + repeated fixed64 F_Fixed64_repeated = 24; + repeated uint32 F_Uint32_repeated = 25; + repeated uint64 F_Uint64_repeated = 26; + repeated float F_Float_repeated = 27; + repeated double F_Double_repeated = 28; + repeated string F_String_repeated = 29; + repeated bytes F_Bytes_repeated = 201; + repeated sint32 F_Sint32_repeated = 202; + repeated sint64 F_Sint64_repeated = 203; + + // Optional fields of all basic types + optional bool F_Bool_optional = 30; + optional int32 F_Int32_optional = 31; + optional int64 F_Int64_optional = 32; + optional fixed32 F_Fixed32_optional = 33; + optional fixed64 F_Fixed64_optional = 34; + optional uint32 F_Uint32_optional = 35; + optional uint64 F_Uint64_optional = 36; + optional float F_Float_optional = 37; + optional double F_Double_optional = 38; + optional string F_String_optional = 39; + optional bytes F_Bytes_optional = 301; + optional sint32 F_Sint32_optional = 302; + optional sint64 F_Sint64_optional = 303; + + // Default-valued fields of all basic types + optional bool F_Bool_defaulted = 40 [default=true]; + optional int32 F_Int32_defaulted = 41 [default=32]; + optional int64 F_Int64_defaulted = 42 [default=64]; + optional fixed32 F_Fixed32_defaulted = 43 [default=320]; + optional fixed64 F_Fixed64_defaulted = 44 [default=640]; + optional uint32 F_Uint32_defaulted = 45 [default=3200]; + optional uint64 F_Uint64_defaulted = 46 [default=6400]; + optional float F_Float_defaulted = 47 [default=314159.]; + optional double F_Double_defaulted = 48 [default=271828.]; + optional string F_String_defaulted = 49 [default="hello, \"world!\"\n"]; + optional bytes F_Bytes_defaulted = 401 [default="Bignose"]; + optional sint32 F_Sint32_defaulted = 402 [default = -32]; + optional sint64 F_Sint64_defaulted = 403 [default = -64]; + + // Packed repeated fields (no string or bytes). + repeated bool F_Bool_repeated_packed = 50 [packed=true]; + repeated int32 F_Int32_repeated_packed = 51 [packed=true]; + repeated int64 F_Int64_repeated_packed = 52 [packed=true]; + repeated fixed32 F_Fixed32_repeated_packed = 53 [packed=true]; + repeated fixed64 F_Fixed64_repeated_packed = 54 [packed=true]; + repeated uint32 F_Uint32_repeated_packed = 55 [packed=true]; + repeated uint64 F_Uint64_repeated_packed = 56 [packed=true]; + repeated float F_Float_repeated_packed = 57 [packed=true]; + repeated double F_Double_repeated_packed = 58 [packed=true]; + repeated sint32 F_Sint32_repeated_packed = 502 [packed=true]; + repeated sint64 F_Sint64_repeated_packed = 503 [packed=true]; + + // Required, repeated, and optional groups. + required group RequiredGroup = 70 { + required string RequiredField = 71; + }; + + repeated group RepeatedGroup = 80 { + required string RequiredField = 81; + }; + + optional group OptionalGroup = 90 { + required string RequiredField = 91; + }; +} + +// For testing skipping of unrecognized fields. +// Numbers are all big, larger than tag numbers in GoTestField, +// the message used in the corresponding test. +message GoSkipTest { + required int32 skip_int32 = 11; + required fixed32 skip_fixed32 = 12; + required fixed64 skip_fixed64 = 13; + required string skip_string = 14; + required group SkipGroup = 15 { + required int32 group_int32 = 16; + required string group_string = 17; + } +} + +// For testing packed/non-packed decoder switching. +// A serialized instance of one should be deserializable as the other. +message NonPackedTest { + repeated int32 a = 1; +} + +message PackedTest { + repeated int32 b = 1 [packed=true]; +} + +message MaxTag { + // Maximum possible tag number. + optional string last_field = 536870911; +} + +message OldMessage { + message Nested { + optional string name = 1; + } + optional Nested nested = 1; + + optional int32 num = 2; +} + +// NewMessage is wire compatible with OldMessage; +// imagine it as a future version. +message NewMessage { + message Nested { + optional string name = 1; + optional string food_group = 2; + } + optional Nested nested = 1; + + // This is an int32 in OldMessage. + optional int64 num = 2; +} + +// Smaller tests for ASCII formatting. + +message InnerMessage { + required string host = 1; + optional int32 port = 2 [default=4000]; + optional bool connected = 3; +} + +message OtherMessage { + optional int64 key = 1; + optional bytes value = 2; + optional float weight = 3; + optional InnerMessage inner = 4; +} + +message MyMessage { + required int32 count = 1; + optional string name = 2; + optional string quote = 3; + repeated string pet = 4; + optional InnerMessage inner = 5; + repeated OtherMessage others = 6; + repeated InnerMessage rep_inner = 12; + + enum Color { + RED = 0; + GREEN = 1; + BLUE = 2; + }; + optional Color bikeshed = 7; + + optional group SomeGroup = 8 { + optional int32 group_field = 9; + } + + // This field becomes [][]byte in the generated code. + repeated bytes rep_bytes = 10; + + optional double bigfloat = 11; + + extensions 100 to max; +} + +message Ext { + extend MyMessage { + optional Ext more = 103; + optional string text = 104; + optional int32 number = 105; + } + + optional string data = 1; +} + +extend MyMessage { + repeated string greeting = 106; +} + +message DefaultsMessage { + enum DefaultsEnum { + ZERO = 0; + ONE = 1; + TWO = 2; + }; + extensions 100 to max; +} + +extend DefaultsMessage { + optional double no_default_double = 101; + optional float no_default_float = 102; + optional int32 no_default_int32 = 103; + optional int64 no_default_int64 = 104; + optional uint32 no_default_uint32 = 105; + optional uint64 no_default_uint64 = 106; + optional sint32 no_default_sint32 = 107; + optional sint64 no_default_sint64 = 108; + optional fixed32 no_default_fixed32 = 109; + optional fixed64 no_default_fixed64 = 110; + optional sfixed32 no_default_sfixed32 = 111; + optional sfixed64 no_default_sfixed64 = 112; + optional bool no_default_bool = 113; + optional string no_default_string = 114; + optional bytes no_default_bytes = 115; + optional DefaultsMessage.DefaultsEnum no_default_enum = 116; + + optional double default_double = 201 [default = 3.1415]; + optional float default_float = 202 [default = 3.14]; + optional int32 default_int32 = 203 [default = 42]; + optional int64 default_int64 = 204 [default = 43]; + optional uint32 default_uint32 = 205 [default = 44]; + optional uint64 default_uint64 = 206 [default = 45]; + optional sint32 default_sint32 = 207 [default = 46]; + optional sint64 default_sint64 = 208 [default = 47]; + optional fixed32 default_fixed32 = 209 [default = 48]; + optional fixed64 default_fixed64 = 210 [default = 49]; + optional sfixed32 default_sfixed32 = 211 [default = 50]; + optional sfixed64 default_sfixed64 = 212 [default = 51]; + optional bool default_bool = 213 [default = true]; + optional string default_string = 214 [default = "Hello, string"]; + optional bytes default_bytes = 215 [default = "Hello, bytes"]; + optional DefaultsMessage.DefaultsEnum default_enum = 216 [default = ONE]; +} + +message MyMessageSet { + option message_set_wire_format = true; + extensions 100 to max; +} + +message Empty { +} + +extend MyMessageSet { + optional Empty x201 = 201; + optional Empty x202 = 202; + optional Empty x203 = 203; + optional Empty x204 = 204; + optional Empty x205 = 205; + optional Empty x206 = 206; + optional Empty x207 = 207; + optional Empty x208 = 208; + optional Empty x209 = 209; + optional Empty x210 = 210; + optional Empty x211 = 211; + optional Empty x212 = 212; + optional Empty x213 = 213; + optional Empty x214 = 214; + optional Empty x215 = 215; + optional Empty x216 = 216; + optional Empty x217 = 217; + optional Empty x218 = 218; + optional Empty x219 = 219; + optional Empty x220 = 220; + optional Empty x221 = 221; + optional Empty x222 = 222; + optional Empty x223 = 223; + optional Empty x224 = 224; + optional Empty x225 = 225; + optional Empty x226 = 226; + optional Empty x227 = 227; + optional Empty x228 = 228; + optional Empty x229 = 229; + optional Empty x230 = 230; + optional Empty x231 = 231; + optional Empty x232 = 232; + optional Empty x233 = 233; + optional Empty x234 = 234; + optional Empty x235 = 235; + optional Empty x236 = 236; + optional Empty x237 = 237; + optional Empty x238 = 238; + optional Empty x239 = 239; + optional Empty x240 = 240; + optional Empty x241 = 241; + optional Empty x242 = 242; + optional Empty x243 = 243; + optional Empty x244 = 244; + optional Empty x245 = 245; + optional Empty x246 = 246; + optional Empty x247 = 247; + optional Empty x248 = 248; + optional Empty x249 = 249; + optional Empty x250 = 250; +} + +message MessageList { + repeated group Message = 1 { + required string name = 2; + required int32 count = 3; + } +} + +message Strings { + optional string string_field = 1; + optional bytes bytes_field = 2; +} + +message Defaults { + enum Color { + RED = 0; + GREEN = 1; + BLUE = 2; + } + + // Default-valued fields of all basic types. + // Same as GoTest, but copied here to make testing easier. + optional bool F_Bool = 1 [default=true]; + optional int32 F_Int32 = 2 [default=32]; + optional int64 F_Int64 = 3 [default=64]; + optional fixed32 F_Fixed32 = 4 [default=320]; + optional fixed64 F_Fixed64 = 5 [default=640]; + optional uint32 F_Uint32 = 6 [default=3200]; + optional uint64 F_Uint64 = 7 [default=6400]; + optional float F_Float = 8 [default=314159.]; + optional double F_Double = 9 [default=271828.]; + optional string F_String = 10 [default="hello, \"world!\"\n"]; + optional bytes F_Bytes = 11 [default="Bignose"]; + optional sint32 F_Sint32 = 12 [default=-32]; + optional sint64 F_Sint64 = 13 [default=-64]; + optional Color F_Enum = 14 [default=GREEN]; + + // More fields with crazy defaults. + optional float F_Pinf = 15 [default=inf]; + optional float F_Ninf = 16 [default=-inf]; + optional float F_Nan = 17 [default=nan]; + + // Sub-message. + optional SubDefaults sub = 18; + + // Redundant but explicit defaults. + optional string str_zero = 19 [default=""]; +} + +message SubDefaults { + optional int64 n = 1 [default=7]; +} + +message RepeatedEnum { + enum Color { + RED = 1; + } + repeated Color color = 1; +} + +message MoreRepeated { + repeated bool bools = 1; + repeated bool bools_packed = 2 [packed=true]; + repeated int32 ints = 3; + repeated int32 ints_packed = 4 [packed=true]; + repeated int64 int64s_packed = 7 [packed=true]; + repeated string strings = 5; + repeated fixed32 fixeds = 6; +} + +// GroupOld and GroupNew have the same wire format. +// GroupNew has a new field inside a group. + +message GroupOld { + optional group G = 101 { + optional int32 x = 2; + } +} + +message GroupNew { + optional group G = 101 { + optional int32 x = 2; + optional int32 y = 3; + } +} + +message FloatingPoint { + required double f = 1; +} + +message MessageWithMap { + map name_mapping = 1; + map msg_mapping = 2; + map byte_mapping = 3; + map str_to_str = 4; +} + +message Communique { + optional bool make_me_cry = 1; + + // This is a oneof, called "union". + oneof union { + int32 number = 5; + string name = 6; + bytes data = 7; + double temp_c = 8; + MyMessage.Color col = 9; + Strings msg = 10; + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/text.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/text.go new file mode 100644 index 0000000000000000000000000000000000000000..c12caecafb99222bcd4c56710af071218bbace45 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/text.go @@ -0,0 +1,833 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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 proto + +// Functions for writing the text protocol buffer format. + +import ( + "bufio" + "bytes" + "encoding" + "errors" + "fmt" + "io" + "log" + "math" + "reflect" + "sort" + "strings" +) + +var ( + newline = []byte("\n") + spaces = []byte(" ") + gtNewline = []byte(">\n") + endBraceNewline = []byte("}\n") + backslashN = []byte{'\\', 'n'} + backslashR = []byte{'\\', 'r'} + backslashT = []byte{'\\', 't'} + backslashDQ = []byte{'\\', '"'} + backslashBS = []byte{'\\', '\\'} + posInf = []byte("inf") + negInf = []byte("-inf") + nan = []byte("nan") +) + +type writer interface { + io.Writer + WriteByte(byte) error +} + +// textWriter is an io.Writer that tracks its indentation level. +type textWriter struct { + ind int + complete bool // if the current position is a complete line + compact bool // whether to write out as a one-liner + w writer +} + +func (w *textWriter) WriteString(s string) (n int, err error) { + if !strings.Contains(s, "\n") { + if !w.compact && w.complete { + w.writeIndent() + } + w.complete = false + return io.WriteString(w.w, s) + } + // WriteString is typically called without newlines, so this + // codepath and its copy are rare. We copy to avoid + // duplicating all of Write's logic here. + return w.Write([]byte(s)) +} + +func (w *textWriter) Write(p []byte) (n int, err error) { + newlines := bytes.Count(p, newline) + if newlines == 0 { + if !w.compact && w.complete { + w.writeIndent() + } + n, err = w.w.Write(p) + w.complete = false + return n, err + } + + frags := bytes.SplitN(p, newline, newlines+1) + if w.compact { + for i, frag := range frags { + if i > 0 { + if err := w.w.WriteByte(' '); err != nil { + return n, err + } + n++ + } + nn, err := w.w.Write(frag) + n += nn + if err != nil { + return n, err + } + } + return n, nil + } + + for i, frag := range frags { + if w.complete { + w.writeIndent() + } + nn, err := w.w.Write(frag) + n += nn + if err != nil { + return n, err + } + if i+1 < len(frags) { + if err := w.w.WriteByte('\n'); err != nil { + return n, err + } + n++ + } + } + w.complete = len(frags[len(frags)-1]) == 0 + return n, nil +} + +func (w *textWriter) WriteByte(c byte) error { + if w.compact && c == '\n' { + c = ' ' + } + if !w.compact && w.complete { + w.writeIndent() + } + err := w.w.WriteByte(c) + w.complete = c == '\n' + return err +} + +func (w *textWriter) indent() { w.ind++ } + +func (w *textWriter) unindent() { + if w.ind == 0 { + log.Printf("proto: textWriter unindented too far") + return + } + w.ind-- +} + +func writeName(w *textWriter, props *Properties) error { + if _, err := w.WriteString(props.OrigName); err != nil { + return err + } + if props.Wire != "group" { + return w.WriteByte(':') + } + return nil +} + +var ( + messageSetType = reflect.TypeOf((*MessageSet)(nil)).Elem() +) + +// raw is the interface satisfied by RawMessage. +type raw interface { + Bytes() []byte +} + +func writeStruct(w *textWriter, sv reflect.Value) error { + if sv.Type() == messageSetType { + return writeMessageSet(w, sv.Addr().Interface().(*MessageSet)) + } + + st := sv.Type() + sprops := GetProperties(st) + for i := 0; i < sv.NumField(); i++ { + fv := sv.Field(i) + props := sprops.Prop[i] + name := st.Field(i).Name + + if strings.HasPrefix(name, "XXX_") { + // There are two XXX_ fields: + // XXX_unrecognized []byte + // XXX_extensions map[int32]proto.Extension + // The first is handled here; + // the second is handled at the bottom of this function. + if name == "XXX_unrecognized" && !fv.IsNil() { + if err := writeUnknownStruct(w, fv.Interface().([]byte)); err != nil { + return err + } + } + continue + } + if fv.Kind() == reflect.Ptr && fv.IsNil() { + // Field not filled in. This could be an optional field or + // a required field that wasn't filled in. Either way, there + // isn't anything we can show for it. + continue + } + if fv.Kind() == reflect.Slice && fv.IsNil() { + // Repeated field that is empty, or a bytes field that is unused. + continue + } + + if props.Repeated && fv.Kind() == reflect.Slice { + // Repeated field. + for j := 0; j < fv.Len(); j++ { + if err := writeName(w, props); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + v := fv.Index(j) + if v.Kind() == reflect.Ptr && v.IsNil() { + // A nil message in a repeated field is not valid, + // but we can handle that more gracefully than panicking. + if _, err := w.Write([]byte("\n")); err != nil { + return err + } + continue + } + if len(props.Enum) > 0 { + if err := writeEnum(w, v, props); err != nil { + return err + } + } else if err := writeAny(w, v, props); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + } + continue + } + if fv.Kind() == reflect.Map { + // Map fields are rendered as a repeated struct with key/value fields. + keys := fv.MapKeys() + sort.Sort(mapKeys(keys)) + for _, key := range keys { + val := fv.MapIndex(key) + if err := writeName(w, props); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + // open struct + if err := w.WriteByte('<'); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte('\n'); err != nil { + return err + } + } + w.indent() + // key + if _, err := w.WriteString("key:"); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + if err := writeAny(w, key, props.mkeyprop); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + // nil values aren't legal, but we can avoid panicking because of them. + if val.Kind() != reflect.Ptr || !val.IsNil() { + // value + if _, err := w.WriteString("value:"); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + if err := writeAny(w, val, props.mvalprop); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + } + // close struct + w.unindent() + if err := w.WriteByte('>'); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + } + continue + } + if props.proto3 && fv.Kind() == reflect.Slice && fv.Len() == 0 { + // empty bytes field + continue + } + if props.proto3 && fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice { + // proto3 non-repeated scalar field; skip if zero value + if isProto3Zero(fv) { + continue + } + } + + if fv.Kind() == reflect.Interface { + // Check if it is a oneof. + if st.Field(i).Tag.Get("protobuf_oneof") != "" { + // fv is nil, or holds a pointer to generated struct. + // That generated struct has exactly one field, + // which has a protobuf struct tag. + if fv.IsNil() { + continue + } + inner := fv.Elem().Elem() // interface -> *T -> T + tag := inner.Type().Field(0).Tag.Get("protobuf") + props.Parse(tag) // Overwrite the outer props. + // Write the value in the oneof, not the oneof itself. + fv = inner.Field(0) + + // Special case to cope with malformed messages gracefully: + // If the value in the oneof is a nil pointer, don't panic + // in writeAny. + if fv.Kind() == reflect.Ptr && fv.IsNil() { + // Use errors.New so writeAny won't render quotes. + msg := errors.New("/* nil */") + fv = reflect.ValueOf(&msg).Elem() + } + } + } + + if err := writeName(w, props); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + if b, ok := fv.Interface().(raw); ok { + if err := writeRaw(w, b.Bytes()); err != nil { + return err + } + continue + } + + if len(props.Enum) > 0 { + if err := writeEnum(w, fv, props); err != nil { + return err + } + } else if err := writeAny(w, fv, props); err != nil { + return err + } + + if err := w.WriteByte('\n'); err != nil { + return err + } + } + + // Extensions (the XXX_extensions field). + pv := sv.Addr() + if pv.Type().Implements(extendableProtoType) { + if err := writeExtensions(w, pv); err != nil { + return err + } + } + + return nil +} + +// writeRaw writes an uninterpreted raw message. +func writeRaw(w *textWriter, b []byte) error { + if err := w.WriteByte('<'); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte('\n'); err != nil { + return err + } + } + w.indent() + if err := writeUnknownStruct(w, b); err != nil { + return err + } + w.unindent() + if err := w.WriteByte('>'); err != nil { + return err + } + return nil +} + +// writeAny writes an arbitrary field. +func writeAny(w *textWriter, v reflect.Value, props *Properties) error { + v = reflect.Indirect(v) + + if props != nil && len(props.CustomType) > 0 { + custom, ok := v.Interface().(Marshaler) + if ok { + data, err := custom.Marshal() + if err != nil { + return err + } + if err := writeString(w, string(data)); err != nil { + return err + } + return nil + } + } + + // Floats have special cases. + if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 { + x := v.Float() + var b []byte + switch { + case math.IsInf(x, 1): + b = posInf + case math.IsInf(x, -1): + b = negInf + case math.IsNaN(x): + b = nan + } + if b != nil { + _, err := w.Write(b) + return err + } + // Other values are handled below. + } + + // We don't attempt to serialise every possible value type; only those + // that can occur in protocol buffers. + switch v.Kind() { + case reflect.Slice: + // Should only be a []byte; repeated fields are handled in writeStruct. + if err := writeString(w, string(v.Bytes())); err != nil { + return err + } + case reflect.String: + if err := writeString(w, v.String()); err != nil { + return err + } + case reflect.Struct: + // Required/optional group/message. + var bra, ket byte = '<', '>' + if props != nil && props.Wire == "group" { + bra, ket = '{', '}' + } + if err := w.WriteByte(bra); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte('\n'); err != nil { + return err + } + } + w.indent() + if tm, ok := v.Interface().(encoding.TextMarshaler); ok { + text, err := tm.MarshalText() + if err != nil { + return err + } + if _, err = w.Write(text); err != nil { + return err + } + } else if err := writeStruct(w, v); err != nil { + return err + } + w.unindent() + if err := w.WriteByte(ket); err != nil { + return err + } + default: + _, err := fmt.Fprint(w, v.Interface()) + return err + } + return nil +} + +// equivalent to C's isprint. +func isprint(c byte) bool { + return c >= 0x20 && c < 0x7f +} + +// writeString writes a string in the protocol buffer text format. +// It is similar to strconv.Quote except we don't use Go escape sequences, +// we treat the string as a byte sequence, and we use octal escapes. +// These differences are to maintain interoperability with the other +// languages' implementations of the text format. +func writeString(w *textWriter, s string) error { + // use WriteByte here to get any needed indent + if err := w.WriteByte('"'); err != nil { + return err + } + // Loop over the bytes, not the runes. + for i := 0; i < len(s); i++ { + var err error + // Divergence from C++: we don't escape apostrophes. + // There's no need to escape them, and the C++ parser + // copes with a naked apostrophe. + switch c := s[i]; c { + case '\n': + _, err = w.w.Write(backslashN) + case '\r': + _, err = w.w.Write(backslashR) + case '\t': + _, err = w.w.Write(backslashT) + case '"': + _, err = w.w.Write(backslashDQ) + case '\\': + _, err = w.w.Write(backslashBS) + default: + if isprint(c) { + err = w.w.WriteByte(c) + } else { + _, err = fmt.Fprintf(w.w, "\\%03o", c) + } + } + if err != nil { + return err + } + } + return w.WriteByte('"') +} + +func writeMessageSet(w *textWriter, ms *MessageSet) error { + for _, item := range ms.Item { + id := *item.TypeId + if msd, ok := messageSetMap[id]; ok { + // Known message set type. + if _, err := fmt.Fprintf(w, "[%s]: <\n", msd.name); err != nil { + return err + } + w.indent() + + pb := reflect.New(msd.t.Elem()) + if err := Unmarshal(item.Message, pb.Interface().(Message)); err != nil { + if _, ferr := fmt.Fprintf(w, "/* bad message: %v */\n", err); ferr != nil { + return ferr + } + } else { + if err := writeStruct(w, pb.Elem()); err != nil { + return err + } + } + } else { + // Unknown type. + if _, err := fmt.Fprintf(w, "[%d]: <\n", id); err != nil { + return err + } + w.indent() + if err := writeUnknownStruct(w, item.Message); err != nil { + return err + } + } + w.unindent() + if _, err := w.Write(gtNewline); err != nil { + return err + } + } + return nil +} + +func writeUnknownStruct(w *textWriter, data []byte) error { + if !w.compact { + if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil { + return err + } + } + b := NewBuffer(data) + for b.index < len(b.buf) { + x, err := b.DecodeVarint() + if err != nil { + _, ferr := fmt.Fprintf(w, "/* %v */\n", err) + return ferr + } + wire, tag := x&7, x>>3 + if wire == WireEndGroup { + w.unindent() + if _, werr := w.Write(endBraceNewline); werr != nil { + return werr + } + continue + } + if _, ferr := fmt.Fprint(w, tag); ferr != nil { + return ferr + } + if wire != WireStartGroup { + if err := w.WriteByte(':'); err != nil { + return err + } + } + if !w.compact || wire == WireStartGroup { + if err := w.WriteByte(' '); err != nil { + return err + } + } + switch wire { + case WireBytes: + buf, e := b.DecodeRawBytes(false) + if e == nil { + _, err = fmt.Fprintf(w, "%q", buf) + } else { + _, err = fmt.Fprintf(w, "/* %v */", e) + } + case WireFixed32: + x, err = b.DecodeFixed32() + err = writeUnknownInt(w, x, err) + case WireFixed64: + x, err = b.DecodeFixed64() + err = writeUnknownInt(w, x, err) + case WireStartGroup: + err = w.WriteByte('{') + w.indent() + case WireVarint: + x, err = b.DecodeVarint() + err = writeUnknownInt(w, x, err) + default: + _, err = fmt.Fprintf(w, "/* unknown wire type %d */", wire) + } + if err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + } + return nil +} + +func writeUnknownInt(w *textWriter, x uint64, err error) error { + if err == nil { + _, err = fmt.Fprint(w, x) + } else { + _, err = fmt.Fprintf(w, "/* %v */", err) + } + return err +} + +type int32Slice []int32 + +func (s int32Slice) Len() int { return len(s) } +func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] } +func (s int32Slice) Swap(i, j int) { s[i], s[j] = s[j], s[i] } + +// writeExtensions writes all the extensions in pv. +// pv is assumed to be a pointer to a protocol message struct that is extendable. +func writeExtensions(w *textWriter, pv reflect.Value) error { + emap := extensionMaps[pv.Type().Elem()] + ep := pv.Interface().(extendableProto) + + // Order the extensions by ID. + // This isn't strictly necessary, but it will give us + // canonical output, which will also make testing easier. + var m map[int32]Extension + if em, ok := ep.(extensionsMap); ok { + m = em.ExtensionMap() + } else if em, ok := ep.(extensionsBytes); ok { + eb := em.GetExtensions() + var err error + m, err = BytesToExtensionsMap(*eb) + if err != nil { + return err + } + } + + ids := make([]int32, 0, len(m)) + for id := range m { + ids = append(ids, id) + } + sort.Sort(int32Slice(ids)) + + for _, extNum := range ids { + ext := m[extNum] + var desc *ExtensionDesc + if emap != nil { + desc = emap[extNum] + } + if desc == nil { + // Unknown extension. + if err := writeUnknownStruct(w, ext.enc); err != nil { + return err + } + continue + } + + pb, err := GetExtension(ep, desc) + if err != nil { + return fmt.Errorf("failed getting extension: %v", err) + } + + // Repeated extensions will appear as a slice. + if !desc.repeated() { + if err := writeExtension(w, desc.Name, pb); err != nil { + return err + } + } else { + v := reflect.ValueOf(pb) + for i := 0; i < v.Len(); i++ { + if err := writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil { + return err + } + } + } + } + return nil +} + +func writeExtension(w *textWriter, name string, pb interface{}) error { + if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + if err := writeAny(w, reflect.ValueOf(pb), nil); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + return nil +} + +func (w *textWriter) writeIndent() { + if !w.complete { + return + } + remain := w.ind * 2 + for remain > 0 { + n := remain + if n > len(spaces) { + n = len(spaces) + } + w.w.Write(spaces[:n]) + remain -= n + } + w.complete = false +} + +func marshalText(w io.Writer, pb Message, compact bool) error { + val := reflect.ValueOf(pb) + if pb == nil || val.IsNil() { + w.Write([]byte("")) + return nil + } + var bw *bufio.Writer + ww, ok := w.(writer) + if !ok { + bw = bufio.NewWriter(w) + ww = bw + } + aw := &textWriter{ + w: ww, + complete: true, + compact: compact, + } + + if tm, ok := pb.(encoding.TextMarshaler); ok { + text, err := tm.MarshalText() + if err != nil { + return err + } + if _, err = aw.Write(text); err != nil { + return err + } + if bw != nil { + return bw.Flush() + } + return nil + } + // Dereference the received pointer so we don't have outer < and >. + v := reflect.Indirect(val) + if err := writeStruct(aw, v); err != nil { + return err + } + if bw != nil { + return bw.Flush() + } + return nil +} + +// MarshalText writes a given protocol buffer in text format. +// The only errors returned are from w. +func MarshalText(w io.Writer, pb Message) error { + return marshalText(w, pb, false) +} + +// MarshalTextString is the same as MarshalText, but returns the string directly. +func MarshalTextString(pb Message) string { + var buf bytes.Buffer + marshalText(&buf, pb, false) + return buf.String() +} + +// CompactText writes a given protocol buffer in compact text format (one line). +func CompactText(w io.Writer, pb Message) error { return marshalText(w, pb, true) } + +// CompactTextString is the same as CompactText, but returns the string directly. +func CompactTextString(pb Message) string { + var buf bytes.Buffer + marshalText(&buf, pb, true) + return buf.String() +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/text_gogo.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/text_gogo.go new file mode 100644 index 0000000000000000000000000000000000000000..cdb23373c39ba1ee49152cf90dcd57bf05add8fa --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/text_gogo.go @@ -0,0 +1,55 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 proto + +import ( + "fmt" + "reflect" +) + +func writeEnum(w *textWriter, v reflect.Value, props *Properties) error { + m, ok := enumStringMaps[props.Enum] + if !ok { + if err := writeAny(w, v, props); err != nil { + return err + } + } + key := int32(0) + if v.Kind() == reflect.Ptr { + key = int32(v.Elem().Int()) + } else { + key = int32(v.Int()) + } + s, ok := m[key] + if !ok { + if err := writeAny(w, v, props); err != nil { + return err + } + } + _, err := fmt.Fprint(w, s) + return err +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/text_parser.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/text_parser.go new file mode 100644 index 0000000000000000000000000000000000000000..acc001fd2780373374833f28e29bfa3a4d703e54 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/text_parser.go @@ -0,0 +1,827 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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 proto + +// Functions for parsing the Text protocol buffer format. +// TODO: message sets. + +import ( + "encoding" + "errors" + "fmt" + "reflect" + "strconv" + "strings" + "unicode/utf8" +) + +type ParseError struct { + Message string + Line int // 1-based line number + Offset int // 0-based byte offset from start of input +} + +func (p *ParseError) Error() string { + if p.Line == 1 { + // show offset only for first line + return fmt.Sprintf("line 1.%d: %v", p.Offset, p.Message) + } + return fmt.Sprintf("line %d: %v", p.Line, p.Message) +} + +type token struct { + value string + err *ParseError + line int // line number + offset int // byte number from start of input, not start of line + unquoted string // the unquoted version of value, if it was a quoted string +} + +func (t *token) String() string { + if t.err == nil { + return fmt.Sprintf("%q (line=%d, offset=%d)", t.value, t.line, t.offset) + } + return fmt.Sprintf("parse error: %v", t.err) +} + +type textParser struct { + s string // remaining input + done bool // whether the parsing is finished (success or error) + backed bool // whether back() was called + offset, line int + cur token +} + +func newTextParser(s string) *textParser { + p := new(textParser) + p.s = s + p.line = 1 + p.cur.line = 1 + return p +} + +func (p *textParser) errorf(format string, a ...interface{}) *ParseError { + pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset} + p.cur.err = pe + p.done = true + return pe +} + +// Numbers and identifiers are matched by [-+._A-Za-z0-9] +func isIdentOrNumberChar(c byte) bool { + switch { + case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z': + return true + case '0' <= c && c <= '9': + return true + } + switch c { + case '-', '+', '.', '_': + return true + } + return false +} + +func isWhitespace(c byte) bool { + switch c { + case ' ', '\t', '\n', '\r': + return true + } + return false +} + +func (p *textParser) skipWhitespace() { + i := 0 + for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') { + if p.s[i] == '#' { + // comment; skip to end of line or input + for i < len(p.s) && p.s[i] != '\n' { + i++ + } + if i == len(p.s) { + break + } + } + if p.s[i] == '\n' { + p.line++ + } + i++ + } + p.offset += i + p.s = p.s[i:len(p.s)] + if len(p.s) == 0 { + p.done = true + } +} + +func (p *textParser) advance() { + // Skip whitespace + p.skipWhitespace() + if p.done { + return + } + + // Start of non-whitespace + p.cur.err = nil + p.cur.offset, p.cur.line = p.offset, p.line + p.cur.unquoted = "" + switch p.s[0] { + case '<', '>', '{', '}', ':', '[', ']', ';', ',': + // Single symbol + p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)] + case '"', '\'': + // Quoted string + i := 1 + for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' { + if p.s[i] == '\\' && i+1 < len(p.s) { + // skip escaped char + i++ + } + i++ + } + if i >= len(p.s) || p.s[i] != p.s[0] { + p.errorf("unmatched quote") + return + } + unq, err := unquoteC(p.s[1:i], rune(p.s[0])) + if err != nil { + p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err) + return + } + p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)] + p.cur.unquoted = unq + default: + i := 0 + for i < len(p.s) && isIdentOrNumberChar(p.s[i]) { + i++ + } + if i == 0 { + p.errorf("unexpected byte %#x", p.s[0]) + return + } + p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)] + } + p.offset += len(p.cur.value) +} + +var ( + errBadUTF8 = errors.New("proto: bad UTF-8") + errBadHex = errors.New("proto: bad hexadecimal") +) + +func unquoteC(s string, quote rune) (string, error) { + // This is based on C++'s tokenizer.cc. + // Despite its name, this is *not* parsing C syntax. + // For instance, "\0" is an invalid quoted string. + + // Avoid allocation in trivial cases. + simple := true + for _, r := range s { + if r == '\\' || r == quote { + simple = false + break + } + } + if simple { + return s, nil + } + + buf := make([]byte, 0, 3*len(s)/2) + for len(s) > 0 { + r, n := utf8.DecodeRuneInString(s) + if r == utf8.RuneError && n == 1 { + return "", errBadUTF8 + } + s = s[n:] + if r != '\\' { + if r < utf8.RuneSelf { + buf = append(buf, byte(r)) + } else { + buf = append(buf, string(r)...) + } + continue + } + + ch, tail, err := unescape(s) + if err != nil { + return "", err + } + buf = append(buf, ch...) + s = tail + } + return string(buf), nil +} + +func unescape(s string) (ch string, tail string, err error) { + r, n := utf8.DecodeRuneInString(s) + if r == utf8.RuneError && n == 1 { + return "", "", errBadUTF8 + } + s = s[n:] + switch r { + case 'a': + return "\a", s, nil + case 'b': + return "\b", s, nil + case 'f': + return "\f", s, nil + case 'n': + return "\n", s, nil + case 'r': + return "\r", s, nil + case 't': + return "\t", s, nil + case 'v': + return "\v", s, nil + case '?': + return "?", s, nil // trigraph workaround + case '\'', '"', '\\': + return string(r), s, nil + case '0', '1', '2', '3', '4', '5', '6', '7', 'x', 'X': + if len(s) < 2 { + return "", "", fmt.Errorf(`\%c requires 2 following digits`, r) + } + base := 8 + ss := s[:2] + s = s[2:] + if r == 'x' || r == 'X' { + base = 16 + } else { + ss = string(r) + ss + } + i, err := strconv.ParseUint(ss, base, 8) + if err != nil { + return "", "", err + } + return string([]byte{byte(i)}), s, nil + case 'u', 'U': + n := 4 + if r == 'U' { + n = 8 + } + if len(s) < n { + return "", "", fmt.Errorf(`\%c requires %d digits`, r, n) + } + + bs := make([]byte, n/2) + for i := 0; i < n; i += 2 { + a, ok1 := unhex(s[i]) + b, ok2 := unhex(s[i+1]) + if !ok1 || !ok2 { + return "", "", errBadHex + } + bs[i/2] = a<<4 | b + } + s = s[n:] + return string(bs), s, nil + } + return "", "", fmt.Errorf(`unknown escape \%c`, r) +} + +// Adapted from src/pkg/strconv/quote.go. +func unhex(b byte) (v byte, ok bool) { + switch { + case '0' <= b && b <= '9': + return b - '0', true + case 'a' <= b && b <= 'f': + return b - 'a' + 10, true + case 'A' <= b && b <= 'F': + return b - 'A' + 10, true + } + return 0, false +} + +// Back off the parser by one token. Can only be done between calls to next(). +// It makes the next advance() a no-op. +func (p *textParser) back() { p.backed = true } + +// Advances the parser and returns the new current token. +func (p *textParser) next() *token { + if p.backed || p.done { + p.backed = false + return &p.cur + } + p.advance() + if p.done { + p.cur.value = "" + } else if len(p.cur.value) > 0 && p.cur.value[0] == '"' { + // Look for multiple quoted strings separated by whitespace, + // and concatenate them. + cat := p.cur + for { + p.skipWhitespace() + if p.done || p.s[0] != '"' { + break + } + p.advance() + if p.cur.err != nil { + return &p.cur + } + cat.value += " " + p.cur.value + cat.unquoted += p.cur.unquoted + } + p.done = false // parser may have seen EOF, but we want to return cat + p.cur = cat + } + return &p.cur +} + +func (p *textParser) consumeToken(s string) error { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value != s { + p.back() + return p.errorf("expected %q, found %q", s, tok.value) + } + return nil +} + +// Return a RequiredNotSetError indicating which required field was not set. +func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSetError { + st := sv.Type() + sprops := GetProperties(st) + for i := 0; i < st.NumField(); i++ { + if !isNil(sv.Field(i)) { + continue + } + + props := sprops.Prop[i] + if props.Required { + return &RequiredNotSetError{fmt.Sprintf("%v.%v", st, props.OrigName)} + } + } + return &RequiredNotSetError{fmt.Sprintf("%v.", st)} // should not happen +} + +// Returns the index in the struct for the named field, as well as the parsed tag properties. +func structFieldByName(sprops *StructProperties, name string) (int, *Properties, bool) { + i, ok := sprops.decoderOrigNames[name] + if ok { + return i, sprops.Prop[i], true + } + return -1, nil, false +} + +// Consume a ':' from the input stream (if the next token is a colon), +// returning an error if a colon is needed but not present. +func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value != ":" { + // Colon is optional when the field is a group or message. + needColon := true + switch props.Wire { + case "group": + needColon = false + case "bytes": + // A "bytes" field is either a message, a string, or a repeated field; + // those three become *T, *string and []T respectively, so we can check for + // this field being a pointer to a non-string. + if typ.Kind() == reflect.Ptr { + // *T or *string + if typ.Elem().Kind() == reflect.String { + break + } + } else if typ.Kind() == reflect.Slice { + // []T or []*T + if typ.Elem().Kind() != reflect.Ptr { + break + } + } else if typ.Kind() == reflect.String { + // The proto3 exception is for a string field, + // which requires a colon. + break + } + needColon = false + } + if needColon { + return p.errorf("expected ':', found %q", tok.value) + } + p.back() + } + return nil +} + +func (p *textParser) readStruct(sv reflect.Value, terminator string) error { + st := sv.Type() + sprops := GetProperties(st) + reqCount := sprops.reqCount + var reqFieldErr error + fieldSet := make(map[string]bool) + // A struct is a sequence of "name: value", terminated by one of + // '>' or '}', or the end of the input. A name may also be + // "[extension]". + for { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value == terminator { + break + } + if tok.value == "[" { + // Looks like an extension. + // + // TODO: Check whether we need to handle + // namespace rooted names (e.g. ".something.Foo"). + tok = p.next() + if tok.err != nil { + return tok.err + } + var desc *ExtensionDesc + // This could be faster, but it's functional. + // TODO: Do something smarter than a linear scan. + for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) { + if d.Name == tok.value { + desc = d + break + } + } + if desc == nil { + return p.errorf("unrecognized extension %q", tok.value) + } + // Check the extension terminator. + tok = p.next() + if tok.err != nil { + return tok.err + } + if tok.value != "]" { + return p.errorf("unrecognized extension terminator %q", tok.value) + } + + props := &Properties{} + props.Parse(desc.Tag) + + typ := reflect.TypeOf(desc.ExtensionType) + if err := p.checkForColon(props, typ); err != nil { + return err + } + + rep := desc.repeated() + + // Read the extension structure, and set it in + // the value we're constructing. + var ext reflect.Value + if !rep { + ext = reflect.New(typ).Elem() + } else { + ext = reflect.New(typ.Elem()).Elem() + } + if err := p.readAny(ext, props); err != nil { + if _, ok := err.(*RequiredNotSetError); !ok { + return err + } + reqFieldErr = err + } + ep := sv.Addr().Interface().(extendableProto) + if !rep { + SetExtension(ep, desc, ext.Interface()) + } else { + old, err := GetExtension(ep, desc) + var sl reflect.Value + if err == nil { + sl = reflect.ValueOf(old) // existing slice + } else { + sl = reflect.MakeSlice(typ, 0, 1) + } + sl = reflect.Append(sl, ext) + SetExtension(ep, desc, sl.Interface()) + } + if err := p.consumeOptionalSeparator(); err != nil { + return err + } + continue + } + + // This is a normal, non-extension field. + name := tok.value + var dst reflect.Value + fi, props, ok := structFieldByName(sprops, name) + if ok { + dst = sv.Field(fi) + } else if oop, ok := sprops.OneofTypes[name]; ok { + // It is a oneof. + props = oop.Prop + nv := reflect.New(oop.Type.Elem()) + dst = nv.Elem().Field(0) + sv.Field(oop.Field).Set(nv) + } + if !dst.IsValid() { + return p.errorf("unknown field name %q in %v", name, st) + } + + if dst.Kind() == reflect.Map { + // Consume any colon. + if err := p.checkForColon(props, dst.Type()); err != nil { + return err + } + + // Construct the map if it doesn't already exist. + if dst.IsNil() { + dst.Set(reflect.MakeMap(dst.Type())) + } + key := reflect.New(dst.Type().Key()).Elem() + val := reflect.New(dst.Type().Elem()).Elem() + + // The map entry should be this sequence of tokens: + // < key : KEY value : VALUE > + // Technically the "key" and "value" could come in any order, + // but in practice they won't. + + tok := p.next() + var terminator string + switch tok.value { + case "<": + terminator = ">" + case "{": + terminator = "}" + default: + return p.errorf("expected '{' or '<', found %q", tok.value) + } + if err := p.consumeToken("key"); err != nil { + return err + } + if err := p.consumeToken(":"); err != nil { + return err + } + if err := p.readAny(key, props.mkeyprop); err != nil { + return err + } + if err := p.consumeOptionalSeparator(); err != nil { + return err + } + if err := p.consumeToken("value"); err != nil { + return err + } + if err := p.checkForColon(props.mvalprop, dst.Type().Elem()); err != nil { + return err + } + if err := p.readAny(val, props.mvalprop); err != nil { + return err + } + if err := p.consumeOptionalSeparator(); err != nil { + return err + } + if err := p.consumeToken(terminator); err != nil { + return err + } + + dst.SetMapIndex(key, val) + continue + } + + // Check that it's not already set if it's not a repeated field. + if !props.Repeated && fieldSet[name] { + return p.errorf("non-repeated field %q was repeated", name) + } + + if err := p.checkForColon(props, dst.Type()); err != nil { + return err + } + + // Parse into the field. + fieldSet[name] = true + if err := p.readAny(dst, props); err != nil { + if _, ok := err.(*RequiredNotSetError); !ok { + return err + } + reqFieldErr = err + } else if props.Required { + reqCount-- + } + + if err := p.consumeOptionalSeparator(); err != nil { + return err + } + + } + + if reqCount > 0 { + return p.missingRequiredFieldError(sv) + } + return reqFieldErr +} + +// consumeOptionalSeparator consumes an optional semicolon or comma. +// It is used in readStruct to provide backward compatibility. +func (p *textParser) consumeOptionalSeparator() error { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value != ";" && tok.value != "," { + p.back() + } + return nil +} + +func (p *textParser) readAny(v reflect.Value, props *Properties) error { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value == "" { + return p.errorf("unexpected EOF") + } + if len(props.CustomType) > 0 { + if props.Repeated { + t := reflect.TypeOf(v.Interface()) + if t.Kind() == reflect.Slice { + tc := reflect.TypeOf(new(Marshaler)) + ok := t.Elem().Implements(tc.Elem()) + if ok { + fv := v + flen := fv.Len() + if flen == fv.Cap() { + nav := reflect.MakeSlice(v.Type(), flen, 2*flen+1) + reflect.Copy(nav, fv) + fv.Set(nav) + } + fv.SetLen(flen + 1) + + // Read one. + p.back() + return p.readAny(fv.Index(flen), props) + } + } + } + if reflect.TypeOf(v.Interface()).Kind() == reflect.Ptr { + custom := reflect.New(props.ctype.Elem()).Interface().(Unmarshaler) + err := custom.Unmarshal([]byte(tok.unquoted)) + if err != nil { + return p.errorf("%v %v: %v", err, v.Type(), tok.value) + } + v.Set(reflect.ValueOf(custom)) + } else { + custom := reflect.New(reflect.TypeOf(v.Interface())).Interface().(Unmarshaler) + err := custom.Unmarshal([]byte(tok.unquoted)) + if err != nil { + return p.errorf("%v %v: %v", err, v.Type(), tok.value) + } + v.Set(reflect.Indirect(reflect.ValueOf(custom))) + } + return nil + } + switch fv := v; fv.Kind() { + case reflect.Slice: + at := v.Type() + if at.Elem().Kind() == reflect.Uint8 { + // Special case for []byte + if tok.value[0] != '"' && tok.value[0] != '\'' { + // Deliberately written out here, as the error after + // this switch statement would write "invalid []byte: ...", + // which is not as user-friendly. + return p.errorf("invalid string: %v", tok.value) + } + bytes := []byte(tok.unquoted) + fv.Set(reflect.ValueOf(bytes)) + return nil + } + // Repeated field. May already exist. + flen := fv.Len() + if flen == fv.Cap() { + nav := reflect.MakeSlice(at, flen, 2*flen+1) + reflect.Copy(nav, fv) + fv.Set(nav) + } + fv.SetLen(flen + 1) + + // Read one. + p.back() + return p.readAny(fv.Index(flen), props) + case reflect.Bool: + // Either "true", "false", 1 or 0. + switch tok.value { + case "true", "1": + fv.SetBool(true) + return nil + case "false", "0": + fv.SetBool(false) + return nil + } + case reflect.Float32, reflect.Float64: + v := tok.value + // Ignore 'f' for compatibility with output generated by C++, but don't + // remove 'f' when the value is "-inf" or "inf". + if strings.HasSuffix(v, "f") && tok.value != "-inf" && tok.value != "inf" { + v = v[:len(v)-1] + } + if f, err := strconv.ParseFloat(v, fv.Type().Bits()); err == nil { + fv.SetFloat(f) + return nil + } + case reflect.Int32: + if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil { + fv.SetInt(x) + return nil + } + + if len(props.Enum) == 0 { + break + } + m, ok := enumValueMaps[props.Enum] + if !ok { + break + } + x, ok := m[tok.value] + if !ok { + break + } + fv.SetInt(int64(x)) + return nil + case reflect.Int64: + if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil { + fv.SetInt(x) + return nil + } + + case reflect.Ptr: + // A basic field (indirected through pointer), or a repeated message/group + p.back() + fv.Set(reflect.New(fv.Type().Elem())) + return p.readAny(fv.Elem(), props) + case reflect.String: + if tok.value[0] == '"' || tok.value[0] == '\'' { + fv.SetString(tok.unquoted) + return nil + } + case reflect.Struct: + var terminator string + switch tok.value { + case "{": + terminator = "}" + case "<": + terminator = ">" + default: + return p.errorf("expected '{' or '<', found %q", tok.value) + } + // TODO: Handle nested messages which implement encoding.TextUnmarshaler. + return p.readStruct(fv, terminator) + case reflect.Uint32: + if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil { + fv.SetUint(uint64(x)) + return nil + } + case reflect.Uint64: + if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil { + fv.SetUint(x) + return nil + } + } + return p.errorf("invalid %v: %v", v.Type(), tok.value) +} + +// UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb +// before starting to unmarshal, so any existing data in pb is always removed. +// If a required field is not set and no other error occurs, +// UnmarshalText returns *RequiredNotSetError. +func UnmarshalText(s string, pb Message) error { + if um, ok := pb.(encoding.TextUnmarshaler); ok { + err := um.UnmarshalText([]byte(s)) + return err + } + pb.Reset() + v := reflect.ValueOf(pb) + if pe := newTextParser(s).readStruct(v.Elem(), ""); pe != nil { + return pe + } + return nil +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/text_parser_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/text_parser_test.go new file mode 100644 index 0000000000000000000000000000000000000000..48ebb95a1d6e12eeccaf8bc7147e648445629fc6 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/text_parser_test.go @@ -0,0 +1,523 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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 proto_test + +import ( + "math" + "reflect" + "testing" + + . "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + proto3pb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/proto3_proto" + . "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata" +) + +type UnmarshalTextTest struct { + in string + err string // if "", no error expected + out *MyMessage +} + +func buildExtStructTest(text string) UnmarshalTextTest { + msg := &MyMessage{ + Count: Int32(42), + } + SetExtension(msg, E_Ext_More, &Ext{ + Data: String("Hello, world!"), + }) + return UnmarshalTextTest{in: text, out: msg} +} + +func buildExtDataTest(text string) UnmarshalTextTest { + msg := &MyMessage{ + Count: Int32(42), + } + SetExtension(msg, E_Ext_Text, String("Hello, world!")) + SetExtension(msg, E_Ext_Number, Int32(1729)) + return UnmarshalTextTest{in: text, out: msg} +} + +func buildExtRepStringTest(text string) UnmarshalTextTest { + msg := &MyMessage{ + Count: Int32(42), + } + if err := SetExtension(msg, E_Greeting, []string{"bula", "hola"}); err != nil { + panic(err) + } + return UnmarshalTextTest{in: text, out: msg} +} + +var unMarshalTextTests = []UnmarshalTextTest{ + // Basic + { + in: " count:42\n name:\"Dave\" ", + out: &MyMessage{ + Count: Int32(42), + Name: String("Dave"), + }, + }, + + // Empty quoted string + { + in: `count:42 name:""`, + out: &MyMessage{ + Count: Int32(42), + Name: String(""), + }, + }, + + // Quoted string concatenation + { + in: `count:42 name: "My name is "` + "\n" + `"elsewhere"`, + out: &MyMessage{ + Count: Int32(42), + Name: String("My name is elsewhere"), + }, + }, + + // Quoted string with escaped apostrophe + { + in: `count:42 name: "HOLIDAY - New Year\'s Day"`, + out: &MyMessage{ + Count: Int32(42), + Name: String("HOLIDAY - New Year's Day"), + }, + }, + + // Quoted string with single quote + { + in: `count:42 name: 'Roger "The Ramster" Ramjet'`, + out: &MyMessage{ + Count: Int32(42), + Name: String(`Roger "The Ramster" Ramjet`), + }, + }, + + // Quoted string with all the accepted special characters from the C++ test + { + in: `count:42 name: ` + "\"\\\"A string with \\' characters \\n and \\r newlines and \\t tabs and \\001 slashes \\\\ and multiple spaces\"", + out: &MyMessage{ + Count: Int32(42), + Name: String("\"A string with ' characters \n and \r newlines and \t tabs and \001 slashes \\ and multiple spaces"), + }, + }, + + // Quoted string with quoted backslash + { + in: `count:42 name: "\\'xyz"`, + out: &MyMessage{ + Count: Int32(42), + Name: String(`\'xyz`), + }, + }, + + // Quoted string with UTF-8 bytes. + { + in: "count:42 name: '\303\277\302\201\xAB'", + out: &MyMessage{ + Count: Int32(42), + Name: String("\303\277\302\201\xAB"), + }, + }, + + // Bad quoted string + { + in: `inner: < host: "\0" >` + "\n", + err: `line 1.15: invalid quoted string "\0": \0 requires 2 following digits`, + }, + + // Number too large for int64 + { + in: "count: 1 others { key: 123456789012345678901 }", + err: "line 1.23: invalid int64: 123456789012345678901", + }, + + // Number too large for int32 + { + in: "count: 1234567890123", + err: "line 1.7: invalid int32: 1234567890123", + }, + + // Number in hexadecimal + { + in: "count: 0x2beef", + out: &MyMessage{ + Count: Int32(0x2beef), + }, + }, + + // Number in octal + { + in: "count: 024601", + out: &MyMessage{ + Count: Int32(024601), + }, + }, + + // Floating point number with "f" suffix + { + in: "count: 4 others:< weight: 17.0f >", + out: &MyMessage{ + Count: Int32(4), + Others: []*OtherMessage{ + { + Weight: Float32(17), + }, + }, + }, + }, + + // Floating point positive infinity + { + in: "count: 4 bigfloat: inf", + out: &MyMessage{ + Count: Int32(4), + Bigfloat: Float64(math.Inf(1)), + }, + }, + + // Floating point negative infinity + { + in: "count: 4 bigfloat: -inf", + out: &MyMessage{ + Count: Int32(4), + Bigfloat: Float64(math.Inf(-1)), + }, + }, + + // Number too large for float32 + { + in: "others:< weight: 12345678901234567890123456789012345678901234567890 >", + err: "line 1.17: invalid float32: 12345678901234567890123456789012345678901234567890", + }, + + // Number posing as a quoted string + { + in: `inner: < host: 12 >` + "\n", + err: `line 1.15: invalid string: 12`, + }, + + // Quoted string posing as int32 + { + in: `count: "12"`, + err: `line 1.7: invalid int32: "12"`, + }, + + // Quoted string posing a float32 + { + in: `others:< weight: "17.4" >`, + err: `line 1.17: invalid float32: "17.4"`, + }, + + // Enum + { + in: `count:42 bikeshed: BLUE`, + out: &MyMessage{ + Count: Int32(42), + Bikeshed: MyMessage_BLUE.Enum(), + }, + }, + + // Repeated field + { + in: `count:42 pet: "horsey" pet:"bunny"`, + out: &MyMessage{ + Count: Int32(42), + Pet: []string{"horsey", "bunny"}, + }, + }, + + // Repeated message with/without colon and <>/{} + { + in: `count:42 others:{} others{} others:<> others:{}`, + out: &MyMessage{ + Count: Int32(42), + Others: []*OtherMessage{ + {}, + {}, + {}, + {}, + }, + }, + }, + + // Missing colon for inner message + { + in: `count:42 inner < host: "cauchy.syd" >`, + out: &MyMessage{ + Count: Int32(42), + Inner: &InnerMessage{ + Host: String("cauchy.syd"), + }, + }, + }, + + // Missing colon for string field + { + in: `name "Dave"`, + err: `line 1.5: expected ':', found "\"Dave\""`, + }, + + // Missing colon for int32 field + { + in: `count 42`, + err: `line 1.6: expected ':', found "42"`, + }, + + // Missing required field + { + in: `name: "Pawel"`, + err: `proto: required field "testdata.MyMessage.count" not set`, + out: &MyMessage{ + Name: String("Pawel"), + }, + }, + + // Repeated non-repeated field + { + in: `name: "Rob" name: "Russ"`, + err: `line 1.12: non-repeated field "name" was repeated`, + }, + + // Group + { + in: `count: 17 SomeGroup { group_field: 12 }`, + out: &MyMessage{ + Count: Int32(17), + Somegroup: &MyMessage_SomeGroup{ + GroupField: Int32(12), + }, + }, + }, + + // Semicolon between fields + { + in: `count:3;name:"Calvin"`, + out: &MyMessage{ + Count: Int32(3), + Name: String("Calvin"), + }, + }, + // Comma between fields + { + in: `count:4,name:"Ezekiel"`, + out: &MyMessage{ + Count: Int32(4), + Name: String("Ezekiel"), + }, + }, + + // Extension + buildExtStructTest(`count: 42 [testdata.Ext.more]:`), + buildExtStructTest(`count: 42 [testdata.Ext.more] {data:"Hello, world!"}`), + buildExtDataTest(`count: 42 [testdata.Ext.text]:"Hello, world!" [testdata.Ext.number]:1729`), + buildExtRepStringTest(`count: 42 [testdata.greeting]:"bula" [testdata.greeting]:"hola"`), + + // Big all-in-one + { + in: "count:42 # Meaning\n" + + `name:"Dave" ` + + `quote:"\"I didn't want to go.\"" ` + + `pet:"bunny" ` + + `pet:"kitty" ` + + `pet:"horsey" ` + + `inner:<` + + ` host:"footrest.syd" ` + + ` port:7001 ` + + ` connected:true ` + + `> ` + + `others:<` + + ` key:3735928559 ` + + ` value:"\x01A\a\f" ` + + `> ` + + `others:<` + + " weight:58.9 # Atomic weight of Co\n" + + ` inner:<` + + ` host:"lesha.mtv" ` + + ` port:8002 ` + + ` >` + + `>`, + out: &MyMessage{ + Count: Int32(42), + Name: String("Dave"), + Quote: String(`"I didn't want to go."`), + Pet: []string{"bunny", "kitty", "horsey"}, + Inner: &InnerMessage{ + Host: String("footrest.syd"), + Port: Int32(7001), + Connected: Bool(true), + }, + Others: []*OtherMessage{ + { + Key: Int64(3735928559), + Value: []byte{0x1, 'A', '\a', '\f'}, + }, + { + Weight: Float32(58.9), + Inner: &InnerMessage{ + Host: String("lesha.mtv"), + Port: Int32(8002), + }, + }, + }, + }, + }, +} + +func TestUnmarshalText(t *testing.T) { + for i, test := range unMarshalTextTests { + pb := new(MyMessage) + err := UnmarshalText(test.in, pb) + if test.err == "" { + // We don't expect failure. + if err != nil { + t.Errorf("Test %d: Unexpected error: %v", i, err) + } else if !reflect.DeepEqual(pb, test.out) { + t.Errorf("Test %d: Incorrect populated \nHave: %v\nWant: %v", + i, pb, test.out) + } + } else { + // We do expect failure. + if err == nil { + t.Errorf("Test %d: Didn't get expected error: %v", i, test.err) + } else if err.Error() != test.err { + t.Errorf("Test %d: Incorrect error.\nHave: %v\nWant: %v", + i, err.Error(), test.err) + } else if _, ok := err.(*RequiredNotSetError); ok && test.out != nil && !reflect.DeepEqual(pb, test.out) { + t.Errorf("Test %d: Incorrect populated \nHave: %v\nWant: %v", + i, pb, test.out) + } + } + } +} + +func TestUnmarshalTextCustomMessage(t *testing.T) { + msg := &textMessage{} + if err := UnmarshalText("custom", msg); err != nil { + t.Errorf("Unexpected error from custom unmarshal: %v", err) + } + if UnmarshalText("not custom", msg) == nil { + t.Errorf("Didn't get expected error from custom unmarshal") + } +} + +// Regression test; this caused a panic. +func TestRepeatedEnum(t *testing.T) { + pb := new(RepeatedEnum) + if err := UnmarshalText("color: RED", pb); err != nil { + t.Fatal(err) + } + exp := &RepeatedEnum{ + Color: []RepeatedEnum_Color{RepeatedEnum_RED}, + } + if !Equal(pb, exp) { + t.Errorf("Incorrect populated \nHave: %v\nWant: %v", pb, exp) + } +} + +func TestProto3TextParsing(t *testing.T) { + m := new(proto3pb.Message) + const in = `name: "Wallace" true_scotsman: true` + want := &proto3pb.Message{ + Name: "Wallace", + TrueScotsman: true, + } + if err := UnmarshalText(in, m); err != nil { + t.Fatal(err) + } + if !Equal(m, want) { + t.Errorf("\n got %v\nwant %v", m, want) + } +} + +func TestMapParsing(t *testing.T) { + m := new(MessageWithMap) + const in = `name_mapping: name_mapping:` + + `msg_mapping:,>` + // separating commas are okay + `msg_mapping>` + // no colon after "value" + `byte_mapping:` + want := &MessageWithMap{ + NameMapping: map[int32]string{ + 1: "Beatles", + 1234: "Feist", + }, + MsgMapping: map[int64]*FloatingPoint{ + -4: {F: Float64(2.0)}, + -2: {F: Float64(4.0)}, + }, + ByteMapping: map[bool][]byte{ + true: []byte("so be it"), + }, + } + if err := UnmarshalText(in, m); err != nil { + t.Fatal(err) + } + if !Equal(m, want) { + t.Errorf("\n got %v\nwant %v", m, want) + } +} + +func TestOneofParsing(t *testing.T) { + const in = `name:"Shrek"` + m := new(Communique) + want := &Communique{Union: &Communique_Name{"Shrek"}} + if err := UnmarshalText(in, m); err != nil { + t.Fatal(err) + } + if !Equal(m, want) { + t.Errorf("\n got %v\nwant %v", m, want) + } +} + +var benchInput string + +func init() { + benchInput = "count: 4\n" + for i := 0; i < 1000; i++ { + benchInput += "pet: \"fido\"\n" + } + + // Check it is valid input. + pb := new(MyMessage) + err := UnmarshalText(benchInput, pb) + if err != nil { + panic("Bad benchmark input: " + err.Error()) + } +} + +func BenchmarkUnmarshalText(b *testing.B) { + pb := new(MyMessage) + for i := 0; i < b.N; i++ { + UnmarshalText(benchInput, pb) + } + b.SetBytes(int64(len(benchInput))) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/text_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/text_test.go new file mode 100644 index 0000000000000000000000000000000000000000..af80ba08c61a37ef626b99b7de5eb13014575d77 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/text_test.go @@ -0,0 +1,474 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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 proto_test + +import ( + "bytes" + "errors" + "io/ioutil" + "math" + "strings" + "testing" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + + proto3pb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/proto3_proto" + pb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto/testdata" +) + +// textMessage implements the methods that allow it to marshal and unmarshal +// itself as text. +type textMessage struct { +} + +func (*textMessage) MarshalText() ([]byte, error) { + return []byte("custom"), nil +} + +func (*textMessage) UnmarshalText(bytes []byte) error { + if string(bytes) != "custom" { + return errors.New("expected 'custom'") + } + return nil +} + +func (*textMessage) Reset() {} +func (*textMessage) String() string { return "" } +func (*textMessage) ProtoMessage() {} + +func newTestMessage() *pb.MyMessage { + msg := &pb.MyMessage{ + Count: proto.Int32(42), + Name: proto.String("Dave"), + Quote: proto.String(`"I didn't want to go."`), + Pet: []string{"bunny", "kitty", "horsey"}, + Inner: &pb.InnerMessage{ + Host: proto.String("footrest.syd"), + Port: proto.Int32(7001), + Connected: proto.Bool(true), + }, + Others: []*pb.OtherMessage{ + { + Key: proto.Int64(0xdeadbeef), + Value: []byte{1, 65, 7, 12}, + }, + { + Weight: proto.Float32(6.022), + Inner: &pb.InnerMessage{ + Host: proto.String("lesha.mtv"), + Port: proto.Int32(8002), + }, + }, + }, + Bikeshed: pb.MyMessage_BLUE.Enum(), + Somegroup: &pb.MyMessage_SomeGroup{ + GroupField: proto.Int32(8), + }, + // One normally wouldn't do this. + // This is an undeclared tag 13, as a varint (wire type 0) with value 4. + XXX_unrecognized: []byte{13<<3 | 0, 4}, + } + ext := &pb.Ext{ + Data: proto.String("Big gobs for big rats"), + } + if err := proto.SetExtension(msg, pb.E_Ext_More, ext); err != nil { + panic(err) + } + greetings := []string{"adg", "easy", "cow"} + if err := proto.SetExtension(msg, pb.E_Greeting, greetings); err != nil { + panic(err) + } + + // Add an unknown extension. We marshal a pb.Ext, and fake the ID. + b, err := proto.Marshal(&pb.Ext{Data: proto.String("3G skiing")}) + if err != nil { + panic(err) + } + b = append(proto.EncodeVarint(201<<3|proto.WireBytes), b...) + proto.SetRawExtension(msg, 201, b) + + // Extensions can be plain fields, too, so let's test that. + b = append(proto.EncodeVarint(202<<3|proto.WireVarint), 19) + proto.SetRawExtension(msg, 202, b) + + return msg +} + +const text = `count: 42 +name: "Dave" +quote: "\"I didn't want to go.\"" +pet: "bunny" +pet: "kitty" +pet: "horsey" +inner: < + host: "footrest.syd" + port: 7001 + connected: true +> +others: < + key: 3735928559 + value: "\001A\007\014" +> +others: < + weight: 6.022 + inner: < + host: "lesha.mtv" + port: 8002 + > +> +bikeshed: BLUE +SomeGroup { + group_field: 8 +} +/* 2 unknown bytes */ +13: 4 +[testdata.Ext.more]: < + data: "Big gobs for big rats" +> +[testdata.greeting]: "adg" +[testdata.greeting]: "easy" +[testdata.greeting]: "cow" +/* 13 unknown bytes */ +201: "\t3G skiing" +/* 3 unknown bytes */ +202: 19 +` + +func TestMarshalText(t *testing.T) { + buf := new(bytes.Buffer) + if err := proto.MarshalText(buf, newTestMessage()); err != nil { + t.Fatalf("proto.MarshalText: %v", err) + } + s := buf.String() + if s != text { + t.Errorf("Got:\n===\n%v===\nExpected:\n===\n%v===\n", s, text) + } +} + +func TestMarshalTextCustomMessage(t *testing.T) { + buf := new(bytes.Buffer) + if err := proto.MarshalText(buf, &textMessage{}); err != nil { + t.Fatalf("proto.MarshalText: %v", err) + } + s := buf.String() + if s != "custom" { + t.Errorf("Got %q, expected %q", s, "custom") + } +} +func TestMarshalTextNil(t *testing.T) { + want := "" + tests := []proto.Message{nil, (*pb.MyMessage)(nil)} + for i, test := range tests { + buf := new(bytes.Buffer) + if err := proto.MarshalText(buf, test); err != nil { + t.Fatal(err) + } + if got := buf.String(); got != want { + t.Errorf("%d: got %q want %q", i, got, want) + } + } +} + +func TestMarshalTextUnknownEnum(t *testing.T) { + // The Color enum only specifies values 0-2. + m := &pb.MyMessage{Bikeshed: pb.MyMessage_Color(3).Enum()} + got := m.String() + const want = `bikeshed:3 ` + if got != want { + t.Errorf("\n got %q\nwant %q", got, want) + } +} + +func TestTextOneof(t *testing.T) { + tests := []struct { + m proto.Message + want string + }{ + // zero message + {&pb.Communique{}, ``}, + // scalar field + {&pb.Communique{Union: &pb.Communique_Number{Number: 4}}, `number:4`}, + // message field + {&pb.Communique{Union: &pb.Communique_Msg{ + Msg: &pb.Strings{StringField: proto.String("why hello!")}, + }}, `msg:`}, + // bad oneof (should not panic) + {&pb.Communique{Union: &pb.Communique_Msg{Msg: nil}}, `msg:/* nil */`}, + } + for _, test := range tests { + got := strings.TrimSpace(test.m.String()) + if got != test.want { + t.Errorf("\n got %s\nwant %s", got, test.want) + } + } +} + +func BenchmarkMarshalTextBuffered(b *testing.B) { + buf := new(bytes.Buffer) + m := newTestMessage() + for i := 0; i < b.N; i++ { + buf.Reset() + proto.MarshalText(buf, m) + } +} + +func BenchmarkMarshalTextUnbuffered(b *testing.B) { + w := ioutil.Discard + m := newTestMessage() + for i := 0; i < b.N; i++ { + proto.MarshalText(w, m) + } +} + +func compact(src string) string { + // s/[ \n]+/ /g; s/ $//; + dst := make([]byte, len(src)) + space, comment := false, false + j := 0 + for i := 0; i < len(src); i++ { + if strings.HasPrefix(src[i:], "/*") { + comment = true + i++ + continue + } + if comment && strings.HasPrefix(src[i:], "*/") { + comment = false + i++ + continue + } + if comment { + continue + } + c := src[i] + if c == ' ' || c == '\n' { + space = true + continue + } + if j > 0 && (dst[j-1] == ':' || dst[j-1] == '<' || dst[j-1] == '{') { + space = false + } + if c == '{' { + space = false + } + if space { + dst[j] = ' ' + j++ + space = false + } + dst[j] = c + j++ + } + if space { + dst[j] = ' ' + j++ + } + return string(dst[0:j]) +} + +var compactText = compact(text) + +func TestCompactText(t *testing.T) { + s := proto.CompactTextString(newTestMessage()) + if s != compactText { + t.Errorf("Got:\n===\n%v===\nExpected:\n===\n%v\n===\n", s, compactText) + } +} + +func TestStringEscaping(t *testing.T) { + testCases := []struct { + in *pb.Strings + out string + }{ + { + // Test data from C++ test (TextFormatTest.StringEscape). + // Single divergence: we don't escape apostrophes. + &pb.Strings{StringField: proto.String("\"A string with ' characters \n and \r newlines and \t tabs and \001 slashes \\ and multiple spaces")}, + "string_field: \"\\\"A string with ' characters \\n and \\r newlines and \\t tabs and \\001 slashes \\\\ and multiple spaces\"\n", + }, + { + // Test data from the same C++ test. + &pb.Strings{StringField: proto.String("\350\260\267\346\255\214")}, + "string_field: \"\\350\\260\\267\\346\\255\\214\"\n", + }, + { + // Some UTF-8. + &pb.Strings{StringField: proto.String("\x00\x01\xff\x81")}, + `string_field: "\000\001\377\201"` + "\n", + }, + } + + for i, tc := range testCases { + var buf bytes.Buffer + if err := proto.MarshalText(&buf, tc.in); err != nil { + t.Errorf("proto.MarsalText: %v", err) + continue + } + s := buf.String() + if s != tc.out { + t.Errorf("#%d: Got:\n%s\nExpected:\n%s\n", i, s, tc.out) + continue + } + + // Check round-trip. + pb := new(pb.Strings) + if err := proto.UnmarshalText(s, pb); err != nil { + t.Errorf("#%d: UnmarshalText: %v", i, err) + continue + } + if !proto.Equal(pb, tc.in) { + t.Errorf("#%d: Round-trip failed:\nstart: %v\n end: %v", i, tc.in, pb) + } + } +} + +// A limitedWriter accepts some output before it fails. +// This is a proxy for something like a nearly-full or imminently-failing disk, +// or a network connection that is about to die. +type limitedWriter struct { + b bytes.Buffer + limit int +} + +var outOfSpace = errors.New("proto: insufficient space") + +func (w *limitedWriter) Write(p []byte) (n int, err error) { + var avail = w.limit - w.b.Len() + if avail <= 0 { + return 0, outOfSpace + } + if len(p) <= avail { + return w.b.Write(p) + } + n, _ = w.b.Write(p[:avail]) + return n, outOfSpace +} + +func TestMarshalTextFailing(t *testing.T) { + // Try lots of different sizes to exercise more error code-paths. + for lim := 0; lim < len(text); lim++ { + buf := new(limitedWriter) + buf.limit = lim + err := proto.MarshalText(buf, newTestMessage()) + // We expect a certain error, but also some partial results in the buffer. + if err != outOfSpace { + t.Errorf("Got:\n===\n%v===\nExpected:\n===\n%v===\n", err, outOfSpace) + } + s := buf.b.String() + x := text[:buf.limit] + if s != x { + t.Errorf("Got:\n===\n%v===\nExpected:\n===\n%v===\n", s, x) + } + } +} + +func TestFloats(t *testing.T) { + tests := []struct { + f float64 + want string + }{ + {0, "0"}, + {4.7, "4.7"}, + {math.Inf(1), "inf"}, + {math.Inf(-1), "-inf"}, + {math.NaN(), "nan"}, + } + for _, test := range tests { + msg := &pb.FloatingPoint{F: &test.f} + got := strings.TrimSpace(msg.String()) + want := `f:` + test.want + if got != want { + t.Errorf("f=%f: got %q, want %q", test.f, got, want) + } + } +} + +func TestRepeatedNilText(t *testing.T) { + m := &pb.MessageList{ + Message: []*pb.MessageList_Message{ + nil, + { + Name: proto.String("Horse"), + }, + nil, + }, + } + want := `Message +Message { + name: "Horse" +} +Message +` + if s := proto.MarshalTextString(m); s != want { + t.Errorf(" got: %s\nwant: %s", s, want) + } +} + +func TestProto3Text(t *testing.T) { + tests := []struct { + m proto.Message + want string + }{ + // zero message + {&proto3pb.Message{}, ``}, + // zero message except for an empty byte slice + {&proto3pb.Message{Data: []byte{}}, ``}, + // trivial case + {&proto3pb.Message{Name: "Rob", HeightInCm: 175}, `name:"Rob" height_in_cm:175`}, + // empty map + {&pb.MessageWithMap{}, ``}, + // non-empty map; map format is the same as a repeated struct, + // and they are sorted by key (numerically for numeric keys). + { + &pb.MessageWithMap{NameMapping: map[int32]string{ + -1: "Negatory", + 7: "Lucky", + 1234: "Feist", + 6345789: "Otis", + }}, + `name_mapping: ` + + `name_mapping: ` + + `name_mapping: ` + + `name_mapping:`, + }, + // map with nil value; not well-defined, but we shouldn't crash + { + &pb.MessageWithMap{MsgMapping: map[int64]*pb.FloatingPoint{7: nil}}, + `msg_mapping:`, + }, + } + for _, test := range tests { + got := strings.TrimSpace(test.m.String()) + if got != test.want { + t.Errorf("\n got %s\nwant %s", got, test.want) + } + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protobuf/google/protobuf/compiler/plugin.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protobuf/google/protobuf/compiler/plugin.proto new file mode 100644 index 0000000000000000000000000000000000000000..d28f22a5e909f0df2be3c9f082c504a4caf477dc --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protobuf/google/protobuf/compiler/plugin.proto @@ -0,0 +1,148 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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. + +// Author: kenton@google.com (Kenton Varda) +// +// WARNING: The plugin interface is currently EXPERIMENTAL and is subject to +// change. +// +// protoc (aka the Protocol Compiler) can be extended via plugins. A plugin is +// just a program that reads a CodeGeneratorRequest from stdin and writes a +// CodeGeneratorResponse to stdout. +// +// Plugins written using C++ can use google/protobuf/compiler/plugin.h instead +// of dealing with the raw protocol defined here. +// +// A plugin executable needs only to be placed somewhere in the path. The +// plugin should be named "protoc-gen-$NAME", and will then be used when the +// flag "--${NAME}_out" is passed to protoc. + +syntax = "proto2"; +package google.protobuf.compiler; +option java_package = "com.google.protobuf.compiler"; +option java_outer_classname = "PluginProtos"; + +import "google/protobuf/descriptor.proto"; + +// An encoded CodeGeneratorRequest is written to the plugin's stdin. +message CodeGeneratorRequest { + // The .proto files that were explicitly listed on the command-line. The + // code generator should generate code only for these files. Each file's + // descriptor will be included in proto_file, below. + repeated string file_to_generate = 1; + + // The generator parameter passed on the command-line. + optional string parameter = 2; + + // FileDescriptorProtos for all files in files_to_generate and everything + // they import. The files will appear in topological order, so each file + // appears before any file that imports it. + // + // protoc guarantees that all proto_files will be written after + // the fields above, even though this is not technically guaranteed by the + // protobuf wire format. This theoretically could allow a plugin to stream + // in the FileDescriptorProtos and handle them one by one rather than read + // the entire set into memory at once. However, as of this writing, this + // is not similarly optimized on protoc's end -- it will store all fields in + // memory at once before sending them to the plugin. + repeated FileDescriptorProto proto_file = 15; +} + +// The plugin writes an encoded CodeGeneratorResponse to stdout. +message CodeGeneratorResponse { + // Error message. If non-empty, code generation failed. The plugin process + // should exit with status code zero even if it reports an error in this way. + // + // This should be used to indicate errors in .proto files which prevent the + // code generator from generating correct code. Errors which indicate a + // problem in protoc itself -- such as the input CodeGeneratorRequest being + // unparseable -- should be reported by writing a message to stderr and + // exiting with a non-zero status code. + optional string error = 1; + + // Represents a single generated file. + message File { + // The file name, relative to the output directory. The name must not + // contain "." or ".." components and must be relative, not be absolute (so, + // the file cannot lie outside the output directory). "/" must be used as + // the path separator, not "\". + // + // If the name is omitted, the content will be appended to the previous + // file. This allows the generator to break large files into small chunks, + // and allows the generated text to be streamed back to protoc so that large + // files need not reside completely in memory at one time. Note that as of + // this writing protoc does not optimize for this -- it will read the entire + // CodeGeneratorResponse before writing files to disk. + optional string name = 1; + + // If non-empty, indicates that the named file should already exist, and the + // content here is to be inserted into that file at a defined insertion + // point. This feature allows a code generator to extend the output + // produced by another code generator. The original generator may provide + // insertion points by placing special annotations in the file that look + // like: + // @@protoc_insertion_point(NAME) + // The annotation can have arbitrary text before and after it on the line, + // which allows it to be placed in a comment. NAME should be replaced with + // an identifier naming the point -- this is what other generators will use + // as the insertion_point. Code inserted at this point will be placed + // immediately above the line containing the insertion point (thus multiple + // insertions to the same point will come out in the order they were added). + // The double-@ is intended to make it unlikely that the generated code + // could contain things that look like insertion points by accident. + // + // For example, the C++ code generator places the following line in the + // .pb.h files that it generates: + // // @@protoc_insertion_point(namespace_scope) + // This line appears within the scope of the file's package namespace, but + // outside of any particular class. Another plugin can then specify the + // insertion_point "namespace_scope" to generate additional classes or + // other declarations that should be placed in this scope. + // + // Note that if the line containing the insertion point begins with + // whitespace, the same whitespace will be added to every line of the + // inserted text. This is useful for languages like Python, where + // indentation matters. In these languages, the insertion point comment + // should be indented the same amount as any inserted code will need to be + // in order to work correctly in that context. + // + // The code generator that generates the initial file and the one which + // inserts into it must both run as part of a single invocation of protoc. + // Code generators are executed in the order in which they appear on the + // command line. + // + // If |insertion_point| is present, |name| must also be present. + optional string insertion_point = 2; + + // The file contents. + optional string content = 15; + } + repeated File file = 15; +} \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protobuf/google/protobuf/descriptor.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protobuf/google/protobuf/descriptor.proto new file mode 100644 index 0000000000000000000000000000000000000000..29b3d7ac27641168ac1c17b88708811b01f3d1e4 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protobuf/google/protobuf/descriptor.proto @@ -0,0 +1,714 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// 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. + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// The messages in this file describe the definitions found in .proto files. +// A valid .proto file can be translated directly to a FileDescriptorProto +// without any other information (e.g. without reading its imports). + + +syntax = "proto2"; + +package google.protobuf; +option java_package = "com.google.protobuf"; +option java_outer_classname = "DescriptorProtos"; + +// descriptor.proto must be optimized for speed because reflection-based +// algorithms don't work during bootstrapping. +option optimize_for = SPEED; + +// The protocol compiler can output a FileDescriptorSet containing the .proto +// files it parses. +message FileDescriptorSet { + repeated FileDescriptorProto file = 1; +} + +// Describes a complete .proto file. +message FileDescriptorProto { + optional string name = 1; // file name, relative to root of source tree + optional string package = 2; // e.g. "foo", "foo.bar", etc. + + // Names of files imported by this file. + repeated string dependency = 3; + // Indexes of the public imported files in the dependency list above. + repeated int32 public_dependency = 10; + // Indexes of the weak imported files in the dependency list. + // For Google-internal migration only. Do not use. + repeated int32 weak_dependency = 11; + + // All top-level definitions in this file. + repeated DescriptorProto message_type = 4; + repeated EnumDescriptorProto enum_type = 5; + repeated ServiceDescriptorProto service = 6; + repeated FieldDescriptorProto extension = 7; + + optional FileOptions options = 8; + + // This field contains optional information about the original source code. + // You may safely remove this entire field without harming runtime + // functionality of the descriptors -- the information is needed only by + // development tools. + optional SourceCodeInfo source_code_info = 9; + + // The syntax of the proto file. + // The supported values are "proto2" and "proto3". + optional string syntax = 12; +} + +// Describes a message type. +message DescriptorProto { + optional string name = 1; + + repeated FieldDescriptorProto field = 2; + repeated FieldDescriptorProto extension = 6; + + repeated DescriptorProto nested_type = 3; + repeated EnumDescriptorProto enum_type = 4; + + message ExtensionRange { + optional int32 start = 1; + optional int32 end = 2; + } + repeated ExtensionRange extension_range = 5; + + repeated OneofDescriptorProto oneof_decl = 8; + + optional MessageOptions options = 7; +} + +// Describes a field within a message. +message FieldDescriptorProto { + enum Type { + // 0 is reserved for errors. + // Order is weird for historical reasons. + TYPE_DOUBLE = 1; + TYPE_FLOAT = 2; + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + // negative values are likely. + TYPE_INT64 = 3; + TYPE_UINT64 = 4; + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + // negative values are likely. + TYPE_INT32 = 5; + TYPE_FIXED64 = 6; + TYPE_FIXED32 = 7; + TYPE_BOOL = 8; + TYPE_STRING = 9; + TYPE_GROUP = 10; // Tag-delimited aggregate. + TYPE_MESSAGE = 11; // Length-delimited aggregate. + + // New in version 2. + TYPE_BYTES = 12; + TYPE_UINT32 = 13; + TYPE_ENUM = 14; + TYPE_SFIXED32 = 15; + TYPE_SFIXED64 = 16; + TYPE_SINT32 = 17; // Uses ZigZag encoding. + TYPE_SINT64 = 18; // Uses ZigZag encoding. + }; + + enum Label { + // 0 is reserved for errors + LABEL_OPTIONAL = 1; + LABEL_REQUIRED = 2; + LABEL_REPEATED = 3; + // TODO(sanjay): Should we add LABEL_MAP? + }; + + optional string name = 1; + optional int32 number = 3; + optional Label label = 4; + + // If type_name is set, this need not be set. If both this and type_name + // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. + optional Type type = 5; + + // For message and enum types, this is the name of the type. If the name + // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping + // rules are used to find the type (i.e. first the nested types within this + // message are searched, then within the parent, on up to the root + // namespace). + optional string type_name = 6; + + // For extensions, this is the name of the type being extended. It is + // resolved in the same manner as type_name. + optional string extendee = 2; + + // For numeric types, contains the original text representation of the value. + // For booleans, "true" or "false". + // For strings, contains the default text contents (not escaped in any way). + // For bytes, contains the C escaped value. All bytes >= 128 are escaped. + // TODO(kenton): Base-64 encode? + optional string default_value = 7; + + // If set, gives the index of a oneof in the containing type's oneof_decl + // list. This field is a member of that oneof. Extensions of a oneof should + // not set this since the oneof to which they belong will be inferred based + // on the extension range containing the extension's field number. + optional int32 oneof_index = 9; + + optional FieldOptions options = 8; +} + +// Describes a oneof. +message OneofDescriptorProto { + optional string name = 1; +} + +// Describes an enum type. +message EnumDescriptorProto { + optional string name = 1; + + repeated EnumValueDescriptorProto value = 2; + + optional EnumOptions options = 3; +} + +// Describes a value within an enum. +message EnumValueDescriptorProto { + optional string name = 1; + optional int32 number = 2; + + optional EnumValueOptions options = 3; +} + +// Describes a service. +message ServiceDescriptorProto { + optional string name = 1; + repeated MethodDescriptorProto method = 2; + + optional ServiceOptions options = 3; +} + +// Describes a method of a service. +message MethodDescriptorProto { + optional string name = 1; + + // Input and output type names. These are resolved in the same way as + // FieldDescriptorProto.type_name, but must refer to a message type. + optional string input_type = 2; + optional string output_type = 3; + + optional MethodOptions options = 4; + + // Identifies if client streams multiple client messages + optional bool client_streaming = 5 [default=false]; + // Identifies if server streams multiple server messages + optional bool server_streaming = 6 [default=false]; +} + + +// =================================================================== +// Options + +// Each of the definitions above may have "options" attached. These are +// just annotations which may cause code to be generated slightly differently +// or may contain hints for code that manipulates protocol messages. +// +// Clients may define custom options as extensions of the *Options messages. +// These extensions may not yet be known at parsing time, so the parser cannot +// store the values in them. Instead it stores them in a field in the *Options +// message called uninterpreted_option. This field must have the same name +// across all *Options messages. We then use this field to populate the +// extensions when we build a descriptor, at which point all protos have been +// parsed and so all extensions are known. +// +// Extension numbers for custom options may be chosen as follows: +// * For options which will only be used within a single application or +// organization, or for experimental options, use field numbers 50000 +// through 99999. It is up to you to ensure that you do not use the +// same number for multiple options. +// * For options which will be published and used publicly by multiple +// independent entities, e-mail protobuf-global-extension-registry@google.com +// to reserve extension numbers. Simply provide your project name (e.g. +// Object-C plugin) and your porject website (if available) -- there's no need +// to explain how you intend to use them. Usually you only need one extension +// number. You can declare multiple options with only one extension number by +// putting them in a sub-message. See the Custom Options section of the docs +// for examples: +// https://developers.google.com/protocol-buffers/docs/proto#options +// If this turns out to be popular, a web service will be set up +// to automatically assign option numbers. + + +message FileOptions { + + // Sets the Java package where classes generated from this .proto will be + // placed. By default, the proto package is used, but this is often + // inappropriate because proto packages do not normally start with backwards + // domain names. + optional string java_package = 1; + + + // If set, all the classes from the .proto file are wrapped in a single + // outer class with the given name. This applies to both Proto1 + // (equivalent to the old "--one_java_file" option) and Proto2 (where + // a .proto always translates to a single class, but you may want to + // explicitly choose the class name). + optional string java_outer_classname = 8; + + // If set true, then the Java code generator will generate a separate .java + // file for each top-level message, enum, and service defined in the .proto + // file. Thus, these types will *not* be nested inside the outer class + // named by java_outer_classname. However, the outer class will still be + // generated to contain the file's getDescriptor() method as well as any + // top-level extensions defined in the file. + optional bool java_multiple_files = 10 [default=false]; + + // If set true, then the Java code generator will generate equals() and + // hashCode() methods for all messages defined in the .proto file. + // - In the full runtime, this is purely a speed optimization, as the + // AbstractMessage base class includes reflection-based implementations of + // these methods. + //- In the lite runtime, setting this option changes the semantics of + // equals() and hashCode() to more closely match those of the full runtime; + // the generated methods compute their results based on field values rather + // than object identity. (Implementations should not assume that hashcodes + // will be consistent across runtimes or versions of the protocol compiler.) + optional bool java_generate_equals_and_hash = 20 [default=false]; + + // If set true, then the Java2 code generator will generate code that + // throws an exception whenever an attempt is made to assign a non-UTF-8 + // byte sequence to a string field. + // Message reflection will do the same. + // However, an extension field still accepts non-UTF-8 byte sequences. + // This option has no effect on when used with the lite runtime. + optional bool java_string_check_utf8 = 27 [default=false]; + + + // Generated classes can be optimized for speed or code size. + enum OptimizeMode { + SPEED = 1; // Generate complete code for parsing, serialization, + // etc. + CODE_SIZE = 2; // Use ReflectionOps to implement these methods. + LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime. + } + optional OptimizeMode optimize_for = 9 [default=SPEED]; + + // Sets the Go package where structs generated from this .proto will be + // placed. If omitted, the Go package will be derived from the following: + // - The basename of the package import path, if provided. + // - Otherwise, the package statement in the .proto file, if present. + // - Otherwise, the basename of the .proto file, without extension. + optional string go_package = 11; + + + + // Should generic services be generated in each language? "Generic" services + // are not specific to any particular RPC system. They are generated by the + // main code generators in each language (without additional plugins). + // Generic services were the only kind of service generation supported by + // early versions of google.protobuf. + // + // Generic services are now considered deprecated in favor of using plugins + // that generate code specific to your particular RPC system. Therefore, + // these default to false. Old code which depends on generic services should + // explicitly set them to true. + optional bool cc_generic_services = 16 [default=false]; + optional bool java_generic_services = 17 [default=false]; + optional bool py_generic_services = 18 [default=false]; + + // Is this file deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for everything in the file, or it will be completely ignored; in the very + // least, this is a formalization for deprecating files. + optional bool deprecated = 23 [default=false]; + + + // Enables the use of arenas for the proto messages in this file. This applies + // only to generated classes for C++. + optional bool cc_enable_arenas = 31 [default=false]; + + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message MessageOptions { + // Set true to use the old proto1 MessageSet wire format for extensions. + // This is provided for backwards-compatibility with the MessageSet wire + // format. You should not use this for any other reason: It's less + // efficient, has fewer features, and is more complicated. + // + // The message must be defined exactly as follows: + // message Foo { + // option message_set_wire_format = true; + // extensions 4 to max; + // } + // Note that the message cannot have any defined fields; MessageSets only + // have extensions. + // + // All extensions of your type must be singular messages; e.g. they cannot + // be int32s, enums, or repeated messages. + // + // Because this is an option, the above two restrictions are not enforced by + // the protocol compiler. + optional bool message_set_wire_format = 1 [default=false]; + + // Disables the generation of the standard "descriptor()" accessor, which can + // conflict with a field of the same name. This is meant to make migration + // from proto1 easier; new code should avoid fields named "descriptor". + optional bool no_standard_descriptor_accessor = 2 [default=false]; + + // Is this message deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the message, or it will be completely ignored; in the very least, + // this is a formalization for deprecating messages. + optional bool deprecated = 3 [default=false]; + + // Whether the message is an automatically generated map entry type for the + // maps field. + // + // For maps fields: + // map map_field = 1; + // The parsed descriptor looks like: + // message MapFieldEntry { + // option map_entry = true; + // optional KeyType key = 1; + // optional ValueType value = 2; + // } + // repeated MapFieldEntry map_field = 1; + // + // Implementations may choose not to generate the map_entry=true message, but + // use a native map in the target language to hold the keys and values. + // The reflection APIs in such implementions still need to work as + // if the field is a repeated message field. + // + // NOTE: Do not set the option in .proto files. Always use the maps syntax + // instead. The option should only be implicitly set by the proto compiler + // parser. + optional bool map_entry = 7; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message FieldOptions { + // The ctype option instructs the C++ code generator to use a different + // representation of the field than it normally would. See the specific + // options below. This option is not yet implemented in the open source + // release -- sorry, we'll try to include it in a future version! + optional CType ctype = 1 [default = STRING]; + enum CType { + // Default mode. + STRING = 0; + + CORD = 1; + + STRING_PIECE = 2; + } + // The packed option can be enabled for repeated primitive fields to enable + // a more efficient representation on the wire. Rather than repeatedly + // writing the tag and type for each element, the entire array is encoded as + // a single length-delimited blob. + optional bool packed = 2; + + + + // Should this field be parsed lazily? Lazy applies only to message-type + // fields. It means that when the outer message is initially parsed, the + // inner message's contents will not be parsed but instead stored in encoded + // form. The inner message will actually be parsed when it is first accessed. + // + // This is only a hint. Implementations are free to choose whether to use + // eager or lazy parsing regardless of the value of this option. However, + // setting this option true suggests that the protocol author believes that + // using lazy parsing on this field is worth the additional bookkeeping + // overhead typically needed to implement it. + // + // This option does not affect the public interface of any generated code; + // all method signatures remain the same. Furthermore, thread-safety of the + // interface is not affected by this option; const methods remain safe to + // call from multiple threads concurrently, while non-const methods continue + // to require exclusive access. + // + // + // Note that implementations may choose not to check required fields within + // a lazy sub-message. That is, calling IsInitialized() on the outher message + // may return true even if the inner message has missing required fields. + // This is necessary because otherwise the inner message would have to be + // parsed in order to perform the check, defeating the purpose of lazy + // parsing. An implementation which chooses not to check required fields + // must be consistent about it. That is, for any particular sub-message, the + // implementation must either *always* check its required fields, or *never* + // check its required fields, regardless of whether or not the message has + // been parsed. + optional bool lazy = 5 [default=false]; + + // Is this field deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for accessors, or it will be completely ignored; in the very least, this + // is a formalization for deprecating fields. + optional bool deprecated = 3 [default=false]; + + // For Google-internal migration only. Do not use. + optional bool weak = 10 [default=false]; + + + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message EnumOptions { + + // Set this option to true to allow mapping different tag names to the same + // value. + optional bool allow_alias = 2; + + // Is this enum deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the enum, or it will be completely ignored; in the very least, this + // is a formalization for deprecating enums. + optional bool deprecated = 3 [default=false]; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message EnumValueOptions { + // Is this enum value deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the enum value, or it will be completely ignored; in the very least, + // this is a formalization for deprecating enum values. + optional bool deprecated = 1 [default=false]; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message ServiceOptions { + + // Note: Field numbers 1 through 32 are reserved for Google's internal RPC + // framework. We apologize for hoarding these numbers to ourselves, but + // we were already using them long before we decided to release Protocol + // Buffers. + + // Is this service deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the service, or it will be completely ignored; in the very least, + // this is a formalization for deprecating services. + optional bool deprecated = 33 [default=false]; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message MethodOptions { + + // Note: Field numbers 1 through 32 are reserved for Google's internal RPC + // framework. We apologize for hoarding these numbers to ourselves, but + // we were already using them long before we decided to release Protocol + // Buffers. + + // Is this method deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the method, or it will be completely ignored; in the very least, + // this is a formalization for deprecating methods. + optional bool deprecated = 33 [default=false]; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + + +// A message representing a option the parser does not recognize. This only +// appears in options protos created by the compiler::Parser class. +// DescriptorPool resolves these when building Descriptor objects. Therefore, +// options protos in descriptor objects (e.g. returned by Descriptor::options(), +// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions +// in them. +message UninterpretedOption { + // The name of the uninterpreted option. Each string represents a segment in + // a dot-separated name. is_extension is true iff a segment represents an + // extension (denoted with parentheses in options specs in .proto files). + // E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents + // "foo.(bar.baz).qux". + message NamePart { + required string name_part = 1; + required bool is_extension = 2; + } + repeated NamePart name = 2; + + // The value of the uninterpreted option, in whatever type the tokenizer + // identified it as during parsing. Exactly one of these should be set. + optional string identifier_value = 3; + optional uint64 positive_int_value = 4; + optional int64 negative_int_value = 5; + optional double double_value = 6; + optional bytes string_value = 7; + optional string aggregate_value = 8; +} + +// =================================================================== +// Optional source code info + +// Encapsulates information about the original source file from which a +// FileDescriptorProto was generated. +message SourceCodeInfo { + // A Location identifies a piece of source code in a .proto file which + // corresponds to a particular definition. This information is intended + // to be useful to IDEs, code indexers, documentation generators, and similar + // tools. + // + // For example, say we have a file like: + // message Foo { + // optional string foo = 1; + // } + // Let's look at just the field definition: + // optional string foo = 1; + // ^ ^^ ^^ ^ ^^^ + // a bc de f ghi + // We have the following locations: + // span path represents + // [a,i) [ 4, 0, 2, 0 ] The whole field definition. + // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). + // [c,d) [ 4, 0, 2, 0, 5 ] The type (string). + // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). + // [g,h) [ 4, 0, 2, 0, 3 ] The number (1). + // + // Notes: + // - A location may refer to a repeated field itself (i.e. not to any + // particular index within it). This is used whenever a set of elements are + // logically enclosed in a single code segment. For example, an entire + // extend block (possibly containing multiple extension definitions) will + // have an outer location whose path refers to the "extensions" repeated + // field without an index. + // - Multiple locations may have the same path. This happens when a single + // logical declaration is spread out across multiple places. The most + // obvious example is the "extend" block again -- there may be multiple + // extend blocks in the same scope, each of which will have the same path. + // - A location's span is not always a subset of its parent's span. For + // example, the "extendee" of an extension declaration appears at the + // beginning of the "extend" block and is shared by all extensions within + // the block. + // - Just because a location's span is a subset of some other location's span + // does not mean that it is a descendent. For example, a "group" defines + // both a type and a field in a single declaration. Thus, the locations + // corresponding to the type and field and their components will overlap. + // - Code which tries to interpret locations should probably be designed to + // ignore those that it doesn't understand, as more types of locations could + // be recorded in the future. + repeated Location location = 1; + message Location { + // Identifies which part of the FileDescriptorProto was defined at this + // location. + // + // Each element is a field number or an index. They form a path from + // the root FileDescriptorProto to the place where the definition. For + // example, this path: + // [ 4, 3, 2, 7, 1 ] + // refers to: + // file.message_type(3) // 4, 3 + // .field(7) // 2, 7 + // .name() // 1 + // This is because FileDescriptorProto.message_type has field number 4: + // repeated DescriptorProto message_type = 4; + // and DescriptorProto.field has field number 2: + // repeated FieldDescriptorProto field = 2; + // and FieldDescriptorProto.name has field number 1: + // optional string name = 1; + // + // Thus, the above path gives the location of a field name. If we removed + // the last element: + // [ 4, 3, 2, 7 ] + // this path refers to the whole field declaration (from the beginning + // of the label to the terminating semicolon). + repeated int32 path = 1 [packed=true]; + + // Always has exactly three or four elements: start line, start column, + // end line (optional, otherwise assumed same as start line), end column. + // These are packed into a single field for efficiency. Note that line + // and column numbers are zero-based -- typically you will want to add + // 1 to each before displaying to a user. + repeated int32 span = 2 [packed=true]; + + // If this SourceCodeInfo represents a complete declaration, these are any + // comments appearing before and after the declaration which appear to be + // attached to the declaration. + // + // A series of line comments appearing on consecutive lines, with no other + // tokens appearing on those lines, will be treated as a single comment. + // + // Only the comment content is provided; comment markers (e.g. //) are + // stripped out. For block comments, leading whitespace and an asterisk + // will be stripped from the beginning of each line other than the first. + // Newlines are included in the output. + // + // Examples: + // + // optional int32 foo = 1; // Comment attached to foo. + // // Comment attached to bar. + // optional int32 bar = 2; + // + // optional string baz = 3; + // // Comment attached to baz. + // // Another line attached to baz. + // + // // Comment attached to qux. + // // + // // Another line attached to qux. + // optional double qux = 4; + // + // optional string corge = 5; + // /* Block comment attached + // * to corge. Leading asterisks + // * will be removed. */ + // /* Block comment attached to + // * grault. */ + // optional int32 grault = 6; + optional string leading_comments = 3; + optional string trailing_comments = 4; + } +} \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-combo/combo.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-combo/combo.go new file mode 100644 index 0000000000000000000000000000000000000000..d767f2dfd74e262acf8ba93879d6c08b877be618 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-combo/combo.go @@ -0,0 +1,172 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 main + +import ( + "bufio" + "bytes" + "flag" + "fmt" + "io/ioutil" + "os" + "os/exec" + "path/filepath" + "strings" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/version" +) + +type MixMatch struct { + Old []string + Filename string + Args []string + Plugins string +} + +func (this MixMatch) Gen(folder string, news []string) { + if err := os.MkdirAll(folder, 0777); err != nil { + panic(err) + } + data, err := ioutil.ReadFile(this.Filename) + if err != nil { + panic(err) + } + content := string(data) + for i, old := range this.Old { + if !strings.Contains(content, old) { + panic(fmt.Errorf("could not find string {%s} to replace with {%s}", old, news[i])) + } + content = strings.Replace(content, old, news[i], 1) + if strings.Contains(content, old) && old != news[i] { + panic(fmt.Errorf("found another string {%s} after it was replaced with {%s}", old, news[i])) + } + } + if err := ioutil.WriteFile(filepath.Join(folder, this.Filename), []byte(content), 0666); err != nil { + panic(err) + } + args := append([]string{"--gogo_out=" + this.Plugins + "."}, this.Args...) + args = append(args, filepath.Join(folder, this.Filename)) + var regenerate = exec.Command("protoc", args...) + out, err := regenerate.CombinedOutput() + + failed := false + scanner := bufio.NewScanner(bytes.NewReader(out)) + for scanner.Scan() { + text := scanner.Text() + fmt.Println("protoc-gen-combo: ", text) + if !strings.Contains(text, "WARNING") { + failed = true + } + } + + if err != nil { + fmt.Print("protoc-gen-combo: error: ", err) + failed = true + } + + if failed { + os.Exit(1) + } +} + +var min = flag.String("version", "2.3.0", "minimum protoc version") +var proto_path = flag.String("proto_path", ".", "") +var def = flag.Bool("default", true, "generate the case where everything is false") +var plugins = flag.String("plugins", "", "--gogo_out=plugins=:.") + +func main() { + flag.Parse() + if !version.AtLeast(*min) { + fmt.Printf("protoc version not high enough to parse this proto file\n") + return + } + args := flag.Args() + filename := args[0] + args = append([]string{"--proto_path=" + *proto_path}) + if _, err := exec.LookPath("protoc"); err != nil { + panic("cannot find protoc in PATH") + } + pluginStr := "" + if len(*plugins) > 0 { + pluginStr = "plugins=" + *plugins + ":" + } + m := MixMatch{ + Old: []string{ + "option (gogoproto.unmarshaler_all) = false;", + "option (gogoproto.marshaler_all) = false;", + "option (gogoproto.unsafe_unmarshaler_all) = false;", + "option (gogoproto.unsafe_marshaler_all) = false;", + }, + Filename: filename, + Args: args, + Plugins: pluginStr, + } + if *def { + m.Gen("./combos/neither/", []string{ + "option (gogoproto.unmarshaler_all) = false;", + "option (gogoproto.marshaler_all) = false;", + "option (gogoproto.unsafe_unmarshaler_all) = false;", + "option (gogoproto.unsafe_marshaler_all) = false;", + }) + } + m.Gen("./combos/marshaler/", []string{ + "option (gogoproto.unmarshaler_all) = false;", + "option (gogoproto.marshaler_all) = true;", + "option (gogoproto.unsafe_unmarshaler_all) = false;", + "option (gogoproto.unsafe_marshaler_all) = false;", + }) + m.Gen("./combos/unmarshaler/", []string{ + "option (gogoproto.unmarshaler_all) = true;", + "option (gogoproto.marshaler_all) = false;", + "option (gogoproto.unsafe_unmarshaler_all) = false;", + "option (gogoproto.unsafe_marshaler_all) = false;", + }) + m.Gen("./combos/both/", []string{ + "option (gogoproto.unmarshaler_all) = true;", + "option (gogoproto.marshaler_all) = true;", + "option (gogoproto.unsafe_unmarshaler_all) = false;", + "option (gogoproto.unsafe_marshaler_all) = false;", + }) + m.Gen("./combos/unsafemarshaler/", []string{ + "option (gogoproto.unmarshaler_all) = false;", + "option (gogoproto.marshaler_all) = false;", + "option (gogoproto.unsafe_unmarshaler_all) = false;", + "option (gogoproto.unsafe_marshaler_all) = true;", + }) + m.Gen("./combos/unsafeunmarshaler/", []string{ + "option (gogoproto.unmarshaler_all) = false;", + "option (gogoproto.marshaler_all) = false;", + "option (gogoproto.unsafe_unmarshaler_all) = true;", + "option (gogoproto.unsafe_marshaler_all) = false;", + }) + m.Gen("./combos/unsafeboth/", []string{ + "option (gogoproto.unmarshaler_all) = false;", + "option (gogoproto.marshaler_all) = false;", + "option (gogoproto.unsafe_unmarshaler_all) = true;", + "option (gogoproto.unsafe_marshaler_all) = true;", + }) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gofast/main.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gofast/main.go new file mode 100644 index 0000000000000000000000000000000000000000..6a54191738a668e39f0d2079170af2185479da33 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gofast/main.go @@ -0,0 +1,48 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 main + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/command" +) + +func main() { + req := command.Read() + files := req.GetProtoFile() + + vanity.ForEachFile(files, vanity.TurnOffGogoImport) + + vanity.ForEachFile(files, vanity.TurnOnMarshalerAll) + vanity.ForEachFile(files, vanity.TurnOnSizerAll) + vanity.ForEachFile(files, vanity.TurnOnUnmarshalerAll) + + resp := command.Generate(req) + command.Write(resp) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..a42cc3717f9a278d093432b78dfa487493501eaf --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/Makefile @@ -0,0 +1,33 @@ +# Go support for Protocol Buffers - Google's data interchange format +# +# Copyright 2010 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. + +test: + cd testdata && make test diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..d80ceffee21d07ac030529e60bc41395ee8c4abb --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor/Makefile @@ -0,0 +1,33 @@ +# Go support for Protocol Buffers - Google's data interchange format +# +# Copyright 2010 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 --gogo_out=. -I=../../protobuf/google/protobuf ../../protobuf/google/protobuf/descriptor.proto diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor/descriptor.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor/descriptor.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..1219acac6bb4fb0b043a00e6e65bc28ba4737d31 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor/descriptor.pb.go @@ -0,0 +1,1637 @@ +// Code generated by protoc-gen-gogo. +// source: descriptor.proto +// DO NOT EDIT! + +/* +Package google_protobuf is a generated protocol buffer package. + +It is generated from these files: + descriptor.proto + +It has these top-level messages: + FileDescriptorSet + FileDescriptorProto + DescriptorProto + FieldDescriptorProto + OneofDescriptorProto + EnumDescriptorProto + EnumValueDescriptorProto + ServiceDescriptorProto + MethodDescriptorProto + FileOptions + MessageOptions + FieldOptions + EnumOptions + EnumValueOptions + ServiceOptions + MethodOptions + UninterpretedOption + SourceCodeInfo +*/ +package google_protobuf + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type FieldDescriptorProto_Type int32 + +const ( + // 0 is reserved for errors. + // Order is weird for historical reasons. + FieldDescriptorProto_TYPE_DOUBLE FieldDescriptorProto_Type = 1 + FieldDescriptorProto_TYPE_FLOAT FieldDescriptorProto_Type = 2 + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + // negative values are likely. + FieldDescriptorProto_TYPE_INT64 FieldDescriptorProto_Type = 3 + FieldDescriptorProto_TYPE_UINT64 FieldDescriptorProto_Type = 4 + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + // negative values are likely. + FieldDescriptorProto_TYPE_INT32 FieldDescriptorProto_Type = 5 + FieldDescriptorProto_TYPE_FIXED64 FieldDescriptorProto_Type = 6 + FieldDescriptorProto_TYPE_FIXED32 FieldDescriptorProto_Type = 7 + FieldDescriptorProto_TYPE_BOOL FieldDescriptorProto_Type = 8 + FieldDescriptorProto_TYPE_STRING FieldDescriptorProto_Type = 9 + FieldDescriptorProto_TYPE_GROUP FieldDescriptorProto_Type = 10 + FieldDescriptorProto_TYPE_MESSAGE FieldDescriptorProto_Type = 11 + // New in version 2. + FieldDescriptorProto_TYPE_BYTES FieldDescriptorProto_Type = 12 + FieldDescriptorProto_TYPE_UINT32 FieldDescriptorProto_Type = 13 + FieldDescriptorProto_TYPE_ENUM FieldDescriptorProto_Type = 14 + FieldDescriptorProto_TYPE_SFIXED32 FieldDescriptorProto_Type = 15 + FieldDescriptorProto_TYPE_SFIXED64 FieldDescriptorProto_Type = 16 + FieldDescriptorProto_TYPE_SINT32 FieldDescriptorProto_Type = 17 + FieldDescriptorProto_TYPE_SINT64 FieldDescriptorProto_Type = 18 +) + +var FieldDescriptorProto_Type_name = map[int32]string{ + 1: "TYPE_DOUBLE", + 2: "TYPE_FLOAT", + 3: "TYPE_INT64", + 4: "TYPE_UINT64", + 5: "TYPE_INT32", + 6: "TYPE_FIXED64", + 7: "TYPE_FIXED32", + 8: "TYPE_BOOL", + 9: "TYPE_STRING", + 10: "TYPE_GROUP", + 11: "TYPE_MESSAGE", + 12: "TYPE_BYTES", + 13: "TYPE_UINT32", + 14: "TYPE_ENUM", + 15: "TYPE_SFIXED32", + 16: "TYPE_SFIXED64", + 17: "TYPE_SINT32", + 18: "TYPE_SINT64", +} +var FieldDescriptorProto_Type_value = map[string]int32{ + "TYPE_DOUBLE": 1, + "TYPE_FLOAT": 2, + "TYPE_INT64": 3, + "TYPE_UINT64": 4, + "TYPE_INT32": 5, + "TYPE_FIXED64": 6, + "TYPE_FIXED32": 7, + "TYPE_BOOL": 8, + "TYPE_STRING": 9, + "TYPE_GROUP": 10, + "TYPE_MESSAGE": 11, + "TYPE_BYTES": 12, + "TYPE_UINT32": 13, + "TYPE_ENUM": 14, + "TYPE_SFIXED32": 15, + "TYPE_SFIXED64": 16, + "TYPE_SINT32": 17, + "TYPE_SINT64": 18, +} + +func (x FieldDescriptorProto_Type) Enum() *FieldDescriptorProto_Type { + p := new(FieldDescriptorProto_Type) + *p = x + return p +} +func (x FieldDescriptorProto_Type) String() string { + return proto.EnumName(FieldDescriptorProto_Type_name, int32(x)) +} +func (x *FieldDescriptorProto_Type) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Type_value, data, "FieldDescriptorProto_Type") + if err != nil { + return err + } + *x = FieldDescriptorProto_Type(value) + return nil +} + +type FieldDescriptorProto_Label int32 + +const ( + // 0 is reserved for errors + FieldDescriptorProto_LABEL_OPTIONAL FieldDescriptorProto_Label = 1 + FieldDescriptorProto_LABEL_REQUIRED FieldDescriptorProto_Label = 2 + FieldDescriptorProto_LABEL_REPEATED FieldDescriptorProto_Label = 3 +) + +var FieldDescriptorProto_Label_name = map[int32]string{ + 1: "LABEL_OPTIONAL", + 2: "LABEL_REQUIRED", + 3: "LABEL_REPEATED", +} +var FieldDescriptorProto_Label_value = map[string]int32{ + "LABEL_OPTIONAL": 1, + "LABEL_REQUIRED": 2, + "LABEL_REPEATED": 3, +} + +func (x FieldDescriptorProto_Label) Enum() *FieldDescriptorProto_Label { + p := new(FieldDescriptorProto_Label) + *p = x + return p +} +func (x FieldDescriptorProto_Label) String() string { + return proto.EnumName(FieldDescriptorProto_Label_name, int32(x)) +} +func (x *FieldDescriptorProto_Label) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Label_value, data, "FieldDescriptorProto_Label") + if err != nil { + return err + } + *x = FieldDescriptorProto_Label(value) + return nil +} + +// Generated classes can be optimized for speed or code size. +type FileOptions_OptimizeMode int32 + +const ( + FileOptions_SPEED FileOptions_OptimizeMode = 1 + // etc. + FileOptions_CODE_SIZE FileOptions_OptimizeMode = 2 + FileOptions_LITE_RUNTIME FileOptions_OptimizeMode = 3 +) + +var FileOptions_OptimizeMode_name = map[int32]string{ + 1: "SPEED", + 2: "CODE_SIZE", + 3: "LITE_RUNTIME", +} +var FileOptions_OptimizeMode_value = map[string]int32{ + "SPEED": 1, + "CODE_SIZE": 2, + "LITE_RUNTIME": 3, +} + +func (x FileOptions_OptimizeMode) Enum() *FileOptions_OptimizeMode { + p := new(FileOptions_OptimizeMode) + *p = x + return p +} +func (x FileOptions_OptimizeMode) String() string { + return proto.EnumName(FileOptions_OptimizeMode_name, int32(x)) +} +func (x *FileOptions_OptimizeMode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FileOptions_OptimizeMode_value, data, "FileOptions_OptimizeMode") + if err != nil { + return err + } + *x = FileOptions_OptimizeMode(value) + return nil +} + +type FieldOptions_CType int32 + +const ( + // Default mode. + FieldOptions_STRING FieldOptions_CType = 0 + FieldOptions_CORD FieldOptions_CType = 1 + FieldOptions_STRING_PIECE FieldOptions_CType = 2 +) + +var FieldOptions_CType_name = map[int32]string{ + 0: "STRING", + 1: "CORD", + 2: "STRING_PIECE", +} +var FieldOptions_CType_value = map[string]int32{ + "STRING": 0, + "CORD": 1, + "STRING_PIECE": 2, +} + +func (x FieldOptions_CType) Enum() *FieldOptions_CType { + p := new(FieldOptions_CType) + *p = x + return p +} +func (x FieldOptions_CType) String() string { + return proto.EnumName(FieldOptions_CType_name, int32(x)) +} +func (x *FieldOptions_CType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FieldOptions_CType_value, data, "FieldOptions_CType") + if err != nil { + return err + } + *x = FieldOptions_CType(value) + return nil +} + +// The protocol compiler can output a FileDescriptorSet containing the .proto +// files it parses. +type FileDescriptorSet struct { + File []*FileDescriptorProto `protobuf:"bytes,1,rep,name=file" json:"file,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FileDescriptorSet) Reset() { *m = FileDescriptorSet{} } +func (m *FileDescriptorSet) String() string { return proto.CompactTextString(m) } +func (*FileDescriptorSet) ProtoMessage() {} + +func (m *FileDescriptorSet) GetFile() []*FileDescriptorProto { + if m != nil { + return m.File + } + return nil +} + +// Describes a complete .proto file. +type FileDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Package *string `protobuf:"bytes,2,opt,name=package" json:"package,omitempty"` + // Names of files imported by this file. + Dependency []string `protobuf:"bytes,3,rep,name=dependency" json:"dependency,omitempty"` + // Indexes of the public imported files in the dependency list above. + PublicDependency []int32 `protobuf:"varint,10,rep,name=public_dependency" json:"public_dependency,omitempty"` + // Indexes of the weak imported files in the dependency list. + // For Google-internal migration only. Do not use. + WeakDependency []int32 `protobuf:"varint,11,rep,name=weak_dependency" json:"weak_dependency,omitempty"` + // All top-level definitions in this file. + MessageType []*DescriptorProto `protobuf:"bytes,4,rep,name=message_type" json:"message_type,omitempty"` + EnumType []*EnumDescriptorProto `protobuf:"bytes,5,rep,name=enum_type" json:"enum_type,omitempty"` + Service []*ServiceDescriptorProto `protobuf:"bytes,6,rep,name=service" json:"service,omitempty"` + Extension []*FieldDescriptorProto `protobuf:"bytes,7,rep,name=extension" json:"extension,omitempty"` + Options *FileOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"` + // This field contains optional information about the original source code. + // You may safely remove this entire field without harming runtime + // functionality of the descriptors -- the information is needed only by + // development tools. + SourceCodeInfo *SourceCodeInfo `protobuf:"bytes,9,opt,name=source_code_info" json:"source_code_info,omitempty"` + // The syntax of the proto file. + // The supported values are "proto2" and "proto3". + Syntax *string `protobuf:"bytes,12,opt,name=syntax" json:"syntax,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FileDescriptorProto) Reset() { *m = FileDescriptorProto{} } +func (m *FileDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*FileDescriptorProto) ProtoMessage() {} + +func (m *FileDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *FileDescriptorProto) GetPackage() string { + if m != nil && m.Package != nil { + return *m.Package + } + return "" +} + +func (m *FileDescriptorProto) GetDependency() []string { + if m != nil { + return m.Dependency + } + return nil +} + +func (m *FileDescriptorProto) GetPublicDependency() []int32 { + if m != nil { + return m.PublicDependency + } + return nil +} + +func (m *FileDescriptorProto) GetWeakDependency() []int32 { + if m != nil { + return m.WeakDependency + } + return nil +} + +func (m *FileDescriptorProto) GetMessageType() []*DescriptorProto { + if m != nil { + return m.MessageType + } + return nil +} + +func (m *FileDescriptorProto) GetEnumType() []*EnumDescriptorProto { + if m != nil { + return m.EnumType + } + return nil +} + +func (m *FileDescriptorProto) GetService() []*ServiceDescriptorProto { + if m != nil { + return m.Service + } + return nil +} + +func (m *FileDescriptorProto) GetExtension() []*FieldDescriptorProto { + if m != nil { + return m.Extension + } + return nil +} + +func (m *FileDescriptorProto) GetOptions() *FileOptions { + if m != nil { + return m.Options + } + return nil +} + +func (m *FileDescriptorProto) GetSourceCodeInfo() *SourceCodeInfo { + if m != nil { + return m.SourceCodeInfo + } + return nil +} + +func (m *FileDescriptorProto) GetSyntax() string { + if m != nil && m.Syntax != nil { + return *m.Syntax + } + return "" +} + +// Describes a message type. +type DescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Field []*FieldDescriptorProto `protobuf:"bytes,2,rep,name=field" json:"field,omitempty"` + Extension []*FieldDescriptorProto `protobuf:"bytes,6,rep,name=extension" json:"extension,omitempty"` + NestedType []*DescriptorProto `protobuf:"bytes,3,rep,name=nested_type" json:"nested_type,omitempty"` + EnumType []*EnumDescriptorProto `protobuf:"bytes,4,rep,name=enum_type" json:"enum_type,omitempty"` + ExtensionRange []*DescriptorProto_ExtensionRange `protobuf:"bytes,5,rep,name=extension_range" json:"extension_range,omitempty"` + OneofDecl []*OneofDescriptorProto `protobuf:"bytes,8,rep,name=oneof_decl" json:"oneof_decl,omitempty"` + Options *MessageOptions `protobuf:"bytes,7,opt,name=options" json:"options,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DescriptorProto) Reset() { *m = DescriptorProto{} } +func (m *DescriptorProto) String() string { return proto.CompactTextString(m) } +func (*DescriptorProto) ProtoMessage() {} + +func (m *DescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *DescriptorProto) GetField() []*FieldDescriptorProto { + if m != nil { + return m.Field + } + return nil +} + +func (m *DescriptorProto) GetExtension() []*FieldDescriptorProto { + if m != nil { + return m.Extension + } + return nil +} + +func (m *DescriptorProto) GetNestedType() []*DescriptorProto { + if m != nil { + return m.NestedType + } + return nil +} + +func (m *DescriptorProto) GetEnumType() []*EnumDescriptorProto { + if m != nil { + return m.EnumType + } + return nil +} + +func (m *DescriptorProto) GetExtensionRange() []*DescriptorProto_ExtensionRange { + if m != nil { + return m.ExtensionRange + } + return nil +} + +func (m *DescriptorProto) GetOneofDecl() []*OneofDescriptorProto { + if m != nil { + return m.OneofDecl + } + return nil +} + +func (m *DescriptorProto) GetOptions() *MessageOptions { + if m != nil { + return m.Options + } + return nil +} + +type DescriptorProto_ExtensionRange struct { + Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` + End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DescriptorProto_ExtensionRange) Reset() { *m = DescriptorProto_ExtensionRange{} } +func (m *DescriptorProto_ExtensionRange) String() string { return proto.CompactTextString(m) } +func (*DescriptorProto_ExtensionRange) ProtoMessage() {} + +func (m *DescriptorProto_ExtensionRange) GetStart() int32 { + if m != nil && m.Start != nil { + return *m.Start + } + return 0 +} + +func (m *DescriptorProto_ExtensionRange) GetEnd() int32 { + if m != nil && m.End != nil { + return *m.End + } + return 0 +} + +// Describes a field within a message. +type FieldDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Number *int32 `protobuf:"varint,3,opt,name=number" json:"number,omitempty"` + Label *FieldDescriptorProto_Label `protobuf:"varint,4,opt,name=label,enum=google.protobuf.FieldDescriptorProto_Label" json:"label,omitempty"` + // If type_name is set, this need not be set. If both this and type_name + // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. + Type *FieldDescriptorProto_Type `protobuf:"varint,5,opt,name=type,enum=google.protobuf.FieldDescriptorProto_Type" json:"type,omitempty"` + // For message and enum types, this is the name of the type. If the name + // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping + // rules are used to find the type (i.e. first the nested types within this + // message are searched, then within the parent, on up to the root + // namespace). + TypeName *string `protobuf:"bytes,6,opt,name=type_name" json:"type_name,omitempty"` + // For extensions, this is the name of the type being extended. It is + // resolved in the same manner as type_name. + Extendee *string `protobuf:"bytes,2,opt,name=extendee" json:"extendee,omitempty"` + // For numeric types, contains the original text representation of the value. + // For booleans, "true" or "false". + // For strings, contains the default text contents (not escaped in any way). + // For bytes, contains the C escaped value. All bytes >= 128 are escaped. + // TODO(kenton): Base-64 encode? + DefaultValue *string `protobuf:"bytes,7,opt,name=default_value" json:"default_value,omitempty"` + // If set, gives the index of a oneof in the containing type's oneof_decl + // list. This field is a member of that oneof. Extensions of a oneof should + // not set this since the oneof to which they belong will be inferred based + // on the extension range containing the extension's field number. + OneofIndex *int32 `protobuf:"varint,9,opt,name=oneof_index" json:"oneof_index,omitempty"` + Options *FieldOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FieldDescriptorProto) Reset() { *m = FieldDescriptorProto{} } +func (m *FieldDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*FieldDescriptorProto) ProtoMessage() {} + +func (m *FieldDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *FieldDescriptorProto) GetNumber() int32 { + if m != nil && m.Number != nil { + return *m.Number + } + return 0 +} + +func (m *FieldDescriptorProto) GetLabel() FieldDescriptorProto_Label { + if m != nil && m.Label != nil { + return *m.Label + } + return FieldDescriptorProto_LABEL_OPTIONAL +} + +func (m *FieldDescriptorProto) GetType() FieldDescriptorProto_Type { + if m != nil && m.Type != nil { + return *m.Type + } + return FieldDescriptorProto_TYPE_DOUBLE +} + +func (m *FieldDescriptorProto) GetTypeName() string { + if m != nil && m.TypeName != nil { + return *m.TypeName + } + return "" +} + +func (m *FieldDescriptorProto) GetExtendee() string { + if m != nil && m.Extendee != nil { + return *m.Extendee + } + return "" +} + +func (m *FieldDescriptorProto) GetDefaultValue() string { + if m != nil && m.DefaultValue != nil { + return *m.DefaultValue + } + return "" +} + +func (m *FieldDescriptorProto) GetOneofIndex() int32 { + if m != nil && m.OneofIndex != nil { + return *m.OneofIndex + } + return 0 +} + +func (m *FieldDescriptorProto) GetOptions() *FieldOptions { + if m != nil { + return m.Options + } + return nil +} + +// Describes a oneof. +type OneofDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OneofDescriptorProto) Reset() { *m = OneofDescriptorProto{} } +func (m *OneofDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*OneofDescriptorProto) ProtoMessage() {} + +func (m *OneofDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +// Describes an enum type. +type EnumDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Value []*EnumValueDescriptorProto `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"` + Options *EnumOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EnumDescriptorProto) Reset() { *m = EnumDescriptorProto{} } +func (m *EnumDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*EnumDescriptorProto) ProtoMessage() {} + +func (m *EnumDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *EnumDescriptorProto) GetValue() []*EnumValueDescriptorProto { + if m != nil { + return m.Value + } + return nil +} + +func (m *EnumDescriptorProto) GetOptions() *EnumOptions { + if m != nil { + return m.Options + } + return nil +} + +// Describes a value within an enum. +type EnumValueDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Number *int32 `protobuf:"varint,2,opt,name=number" json:"number,omitempty"` + Options *EnumValueOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EnumValueDescriptorProto) Reset() { *m = EnumValueDescriptorProto{} } +func (m *EnumValueDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*EnumValueDescriptorProto) ProtoMessage() {} + +func (m *EnumValueDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *EnumValueDescriptorProto) GetNumber() int32 { + if m != nil && m.Number != nil { + return *m.Number + } + return 0 +} + +func (m *EnumValueDescriptorProto) GetOptions() *EnumValueOptions { + if m != nil { + return m.Options + } + return nil +} + +// Describes a service. +type ServiceDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Method []*MethodDescriptorProto `protobuf:"bytes,2,rep,name=method" json:"method,omitempty"` + Options *ServiceOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ServiceDescriptorProto) Reset() { *m = ServiceDescriptorProto{} } +func (m *ServiceDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*ServiceDescriptorProto) ProtoMessage() {} + +func (m *ServiceDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *ServiceDescriptorProto) GetMethod() []*MethodDescriptorProto { + if m != nil { + return m.Method + } + return nil +} + +func (m *ServiceDescriptorProto) GetOptions() *ServiceOptions { + if m != nil { + return m.Options + } + return nil +} + +// Describes a method of a service. +type MethodDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + // Input and output type names. These are resolved in the same way as + // FieldDescriptorProto.type_name, but must refer to a message type. + InputType *string `protobuf:"bytes,2,opt,name=input_type" json:"input_type,omitempty"` + OutputType *string `protobuf:"bytes,3,opt,name=output_type" json:"output_type,omitempty"` + Options *MethodOptions `protobuf:"bytes,4,opt,name=options" json:"options,omitempty"` + // Identifies if client streams multiple client messages + ClientStreaming *bool `protobuf:"varint,5,opt,name=client_streaming,def=0" json:"client_streaming,omitempty"` + // Identifies if server streams multiple server messages + ServerStreaming *bool `protobuf:"varint,6,opt,name=server_streaming,def=0" json:"server_streaming,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MethodDescriptorProto) Reset() { *m = MethodDescriptorProto{} } +func (m *MethodDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*MethodDescriptorProto) ProtoMessage() {} + +const Default_MethodDescriptorProto_ClientStreaming bool = false +const Default_MethodDescriptorProto_ServerStreaming bool = false + +func (m *MethodDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *MethodDescriptorProto) GetInputType() string { + if m != nil && m.InputType != nil { + return *m.InputType + } + return "" +} + +func (m *MethodDescriptorProto) GetOutputType() string { + if m != nil && m.OutputType != nil { + return *m.OutputType + } + return "" +} + +func (m *MethodDescriptorProto) GetOptions() *MethodOptions { + if m != nil { + return m.Options + } + return nil +} + +func (m *MethodDescriptorProto) GetClientStreaming() bool { + if m != nil && m.ClientStreaming != nil { + return *m.ClientStreaming + } + return Default_MethodDescriptorProto_ClientStreaming +} + +func (m *MethodDescriptorProto) GetServerStreaming() bool { + if m != nil && m.ServerStreaming != nil { + return *m.ServerStreaming + } + return Default_MethodDescriptorProto_ServerStreaming +} + +type FileOptions struct { + // Sets the Java package where classes generated from this .proto will be + // placed. By default, the proto package is used, but this is often + // inappropriate because proto packages do not normally start with backwards + // domain names. + JavaPackage *string `protobuf:"bytes,1,opt,name=java_package" json:"java_package,omitempty"` + // If set, all the classes from the .proto file are wrapped in a single + // outer class with the given name. This applies to both Proto1 + // (equivalent to the old "--one_java_file" option) and Proto2 (where + // a .proto always translates to a single class, but you may want to + // explicitly choose the class name). + JavaOuterClassname *string `protobuf:"bytes,8,opt,name=java_outer_classname" json:"java_outer_classname,omitempty"` + // If set true, then the Java code generator will generate a separate .java + // file for each top-level message, enum, and service defined in the .proto + // file. Thus, these types will *not* be nested inside the outer class + // named by java_outer_classname. However, the outer class will still be + // generated to contain the file's getDescriptor() method as well as any + // top-level extensions defined in the file. + JavaMultipleFiles *bool `protobuf:"varint,10,opt,name=java_multiple_files,def=0" json:"java_multiple_files,omitempty"` + // If set true, then the Java code generator will generate equals() and + // hashCode() methods for all messages defined in the .proto file. + // - In the full runtime, this is purely a speed optimization, as the + // AbstractMessage base class includes reflection-based implementations of + // these methods. + // - In the lite runtime, setting this option changes the semantics of + // equals() and hashCode() to more closely match those of the full runtime; + // the generated methods compute their results based on field values rather + // than object identity. (Implementations should not assume that hashcodes + // will be consistent across runtimes or versions of the protocol compiler.) + JavaGenerateEqualsAndHash *bool `protobuf:"varint,20,opt,name=java_generate_equals_and_hash,def=0" json:"java_generate_equals_and_hash,omitempty"` + // If set true, then the Java2 code generator will generate code that + // throws an exception whenever an attempt is made to assign a non-UTF-8 + // byte sequence to a string field. + // Message reflection will do the same. + // However, an extension field still accepts non-UTF-8 byte sequences. + // This option has no effect on when used with the lite runtime. + JavaStringCheckUtf8 *bool `protobuf:"varint,27,opt,name=java_string_check_utf8,def=0" json:"java_string_check_utf8,omitempty"` + OptimizeFor *FileOptions_OptimizeMode `protobuf:"varint,9,opt,name=optimize_for,enum=google.protobuf.FileOptions_OptimizeMode,def=1" json:"optimize_for,omitempty"` + // Sets the Go package where structs generated from this .proto will be + // placed. If omitted, the Go package will be derived from the following: + // - The basename of the package import path, if provided. + // - Otherwise, the package statement in the .proto file, if present. + // - Otherwise, the basename of the .proto file, without extension. + GoPackage *string `protobuf:"bytes,11,opt,name=go_package" json:"go_package,omitempty"` + // Should generic services be generated in each language? "Generic" services + // are not specific to any particular RPC system. They are generated by the + // main code generators in each language (without additional plugins). + // Generic services were the only kind of service generation supported by + // early versions of google.protobuf. + // + // Generic services are now considered deprecated in favor of using plugins + // that generate code specific to your particular RPC system. Therefore, + // these default to false. Old code which depends on generic services should + // explicitly set them to true. + CcGenericServices *bool `protobuf:"varint,16,opt,name=cc_generic_services,def=0" json:"cc_generic_services,omitempty"` + JavaGenericServices *bool `protobuf:"varint,17,opt,name=java_generic_services,def=0" json:"java_generic_services,omitempty"` + PyGenericServices *bool `protobuf:"varint,18,opt,name=py_generic_services,def=0" json:"py_generic_services,omitempty"` + // Is this file deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for everything in the file, or it will be completely ignored; in the very + // least, this is a formalization for deprecating files. + Deprecated *bool `protobuf:"varint,23,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // Enables the use of arenas for the proto messages in this file. This applies + // only to generated classes for C++. + CcEnableArenas *bool `protobuf:"varint,31,opt,name=cc_enable_arenas,def=0" json:"cc_enable_arenas,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option" json:"uninterpreted_option,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FileOptions) Reset() { *m = FileOptions{} } +func (m *FileOptions) String() string { return proto.CompactTextString(m) } +func (*FileOptions) ProtoMessage() {} + +var extRange_FileOptions = []proto.ExtensionRange{ + {1000, 536870911}, +} + +func (*FileOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_FileOptions +} +func (m *FileOptions) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +const Default_FileOptions_JavaMultipleFiles bool = false +const Default_FileOptions_JavaGenerateEqualsAndHash bool = false +const Default_FileOptions_JavaStringCheckUtf8 bool = false +const Default_FileOptions_OptimizeFor FileOptions_OptimizeMode = FileOptions_SPEED +const Default_FileOptions_CcGenericServices bool = false +const Default_FileOptions_JavaGenericServices bool = false +const Default_FileOptions_PyGenericServices bool = false +const Default_FileOptions_Deprecated bool = false +const Default_FileOptions_CcEnableArenas bool = false + +func (m *FileOptions) GetJavaPackage() string { + if m != nil && m.JavaPackage != nil { + return *m.JavaPackage + } + return "" +} + +func (m *FileOptions) GetJavaOuterClassname() string { + if m != nil && m.JavaOuterClassname != nil { + return *m.JavaOuterClassname + } + return "" +} + +func (m *FileOptions) GetJavaMultipleFiles() bool { + if m != nil && m.JavaMultipleFiles != nil { + return *m.JavaMultipleFiles + } + return Default_FileOptions_JavaMultipleFiles +} + +func (m *FileOptions) GetJavaGenerateEqualsAndHash() bool { + if m != nil && m.JavaGenerateEqualsAndHash != nil { + return *m.JavaGenerateEqualsAndHash + } + return Default_FileOptions_JavaGenerateEqualsAndHash +} + +func (m *FileOptions) GetJavaStringCheckUtf8() bool { + if m != nil && m.JavaStringCheckUtf8 != nil { + return *m.JavaStringCheckUtf8 + } + return Default_FileOptions_JavaStringCheckUtf8 +} + +func (m *FileOptions) GetOptimizeFor() FileOptions_OptimizeMode { + if m != nil && m.OptimizeFor != nil { + return *m.OptimizeFor + } + return Default_FileOptions_OptimizeFor +} + +func (m *FileOptions) GetGoPackage() string { + if m != nil && m.GoPackage != nil { + return *m.GoPackage + } + return "" +} + +func (m *FileOptions) GetCcGenericServices() bool { + if m != nil && m.CcGenericServices != nil { + return *m.CcGenericServices + } + return Default_FileOptions_CcGenericServices +} + +func (m *FileOptions) GetJavaGenericServices() bool { + if m != nil && m.JavaGenericServices != nil { + return *m.JavaGenericServices + } + return Default_FileOptions_JavaGenericServices +} + +func (m *FileOptions) GetPyGenericServices() bool { + if m != nil && m.PyGenericServices != nil { + return *m.PyGenericServices + } + return Default_FileOptions_PyGenericServices +} + +func (m *FileOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_FileOptions_Deprecated +} + +func (m *FileOptions) GetCcEnableArenas() bool { + if m != nil && m.CcEnableArenas != nil { + return *m.CcEnableArenas + } + return Default_FileOptions_CcEnableArenas +} + +func (m *FileOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type MessageOptions struct { + // Set true to use the old proto1 MessageSet wire format for extensions. + // This is provided for backwards-compatibility with the MessageSet wire + // format. You should not use this for any other reason: It's less + // efficient, has fewer features, and is more complicated. + // + // The message must be defined exactly as follows: + // message Foo { + // option message_set_wire_format = true; + // extensions 4 to max; + // } + // Note that the message cannot have any defined fields; MessageSets only + // have extensions. + // + // All extensions of your type must be singular messages; e.g. they cannot + // be int32s, enums, or repeated messages. + // + // Because this is an option, the above two restrictions are not enforced by + // the protocol compiler. + MessageSetWireFormat *bool `protobuf:"varint,1,opt,name=message_set_wire_format,def=0" json:"message_set_wire_format,omitempty"` + // Disables the generation of the standard "descriptor()" accessor, which can + // conflict with a field of the same name. This is meant to make migration + // from proto1 easier; new code should avoid fields named "descriptor". + NoStandardDescriptorAccessor *bool `protobuf:"varint,2,opt,name=no_standard_descriptor_accessor,def=0" json:"no_standard_descriptor_accessor,omitempty"` + // Is this message deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the message, or it will be completely ignored; in the very least, + // this is a formalization for deprecating messages. + Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // Whether the message is an automatically generated map entry type for the + // maps field. + // + // For maps fields: + // map map_field = 1; + // The parsed descriptor looks like: + // message MapFieldEntry { + // option map_entry = true; + // optional KeyType key = 1; + // optional ValueType value = 2; + // } + // repeated MapFieldEntry map_field = 1; + // + // Implementations may choose not to generate the map_entry=true message, but + // use a native map in the target language to hold the keys and values. + // The reflection APIs in such implementions still need to work as + // if the field is a repeated message field. + // + // NOTE: Do not set the option in .proto files. Always use the maps syntax + // instead. The option should only be implicitly set by the proto compiler + // parser. + MapEntry *bool `protobuf:"varint,7,opt,name=map_entry" json:"map_entry,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option" json:"uninterpreted_option,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MessageOptions) Reset() { *m = MessageOptions{} } +func (m *MessageOptions) String() string { return proto.CompactTextString(m) } +func (*MessageOptions) ProtoMessage() {} + +var extRange_MessageOptions = []proto.ExtensionRange{ + {1000, 536870911}, +} + +func (*MessageOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MessageOptions +} +func (m *MessageOptions) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +const Default_MessageOptions_MessageSetWireFormat bool = false +const Default_MessageOptions_NoStandardDescriptorAccessor bool = false +const Default_MessageOptions_Deprecated bool = false + +func (m *MessageOptions) GetMessageSetWireFormat() bool { + if m != nil && m.MessageSetWireFormat != nil { + return *m.MessageSetWireFormat + } + return Default_MessageOptions_MessageSetWireFormat +} + +func (m *MessageOptions) GetNoStandardDescriptorAccessor() bool { + if m != nil && m.NoStandardDescriptorAccessor != nil { + return *m.NoStandardDescriptorAccessor + } + return Default_MessageOptions_NoStandardDescriptorAccessor +} + +func (m *MessageOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_MessageOptions_Deprecated +} + +func (m *MessageOptions) GetMapEntry() bool { + if m != nil && m.MapEntry != nil { + return *m.MapEntry + } + return false +} + +func (m *MessageOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type FieldOptions struct { + // The ctype option instructs the C++ code generator to use a different + // representation of the field than it normally would. See the specific + // options below. This option is not yet implemented in the open source + // release -- sorry, we'll try to include it in a future version! + Ctype *FieldOptions_CType `protobuf:"varint,1,opt,name=ctype,enum=google.protobuf.FieldOptions_CType,def=0" json:"ctype,omitempty"` + // The packed option can be enabled for repeated primitive fields to enable + // a more efficient representation on the wire. Rather than repeatedly + // writing the tag and type for each element, the entire array is encoded as + // a single length-delimited blob. + Packed *bool `protobuf:"varint,2,opt,name=packed" json:"packed,omitempty"` + // Should this field be parsed lazily? Lazy applies only to message-type + // fields. It means that when the outer message is initially parsed, the + // inner message's contents will not be parsed but instead stored in encoded + // form. The inner message will actually be parsed when it is first accessed. + // + // This is only a hint. Implementations are free to choose whether to use + // eager or lazy parsing regardless of the value of this option. However, + // setting this option true suggests that the protocol author believes that + // using lazy parsing on this field is worth the additional bookkeeping + // overhead typically needed to implement it. + // + // This option does not affect the public interface of any generated code; + // all method signatures remain the same. Furthermore, thread-safety of the + // interface is not affected by this option; const methods remain safe to + // call from multiple threads concurrently, while non-const methods continue + // to require exclusive access. + // + // + // Note that implementations may choose not to check required fields within + // a lazy sub-message. That is, calling IsInitialized() on the outher message + // may return true even if the inner message has missing required fields. + // This is necessary because otherwise the inner message would have to be + // parsed in order to perform the check, defeating the purpose of lazy + // parsing. An implementation which chooses not to check required fields + // must be consistent about it. That is, for any particular sub-message, the + // implementation must either *always* check its required fields, or *never* + // check its required fields, regardless of whether or not the message has + // been parsed. + Lazy *bool `protobuf:"varint,5,opt,name=lazy,def=0" json:"lazy,omitempty"` + // Is this field deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for accessors, or it will be completely ignored; in the very least, this + // is a formalization for deprecating fields. + Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // For Google-internal migration only. Do not use. + Weak *bool `protobuf:"varint,10,opt,name=weak,def=0" json:"weak,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option" json:"uninterpreted_option,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FieldOptions) Reset() { *m = FieldOptions{} } +func (m *FieldOptions) String() string { return proto.CompactTextString(m) } +func (*FieldOptions) ProtoMessage() {} + +var extRange_FieldOptions = []proto.ExtensionRange{ + {1000, 536870911}, +} + +func (*FieldOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_FieldOptions +} +func (m *FieldOptions) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +const Default_FieldOptions_Ctype FieldOptions_CType = FieldOptions_STRING +const Default_FieldOptions_Lazy bool = false +const Default_FieldOptions_Deprecated bool = false +const Default_FieldOptions_Weak bool = false + +func (m *FieldOptions) GetCtype() FieldOptions_CType { + if m != nil && m.Ctype != nil { + return *m.Ctype + } + return Default_FieldOptions_Ctype +} + +func (m *FieldOptions) GetPacked() bool { + if m != nil && m.Packed != nil { + return *m.Packed + } + return false +} + +func (m *FieldOptions) GetLazy() bool { + if m != nil && m.Lazy != nil { + return *m.Lazy + } + return Default_FieldOptions_Lazy +} + +func (m *FieldOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_FieldOptions_Deprecated +} + +func (m *FieldOptions) GetWeak() bool { + if m != nil && m.Weak != nil { + return *m.Weak + } + return Default_FieldOptions_Weak +} + +func (m *FieldOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type EnumOptions struct { + // Set this option to true to allow mapping different tag names to the same + // value. + AllowAlias *bool `protobuf:"varint,2,opt,name=allow_alias" json:"allow_alias,omitempty"` + // Is this enum deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the enum, or it will be completely ignored; in the very least, this + // is a formalization for deprecating enums. + Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option" json:"uninterpreted_option,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EnumOptions) Reset() { *m = EnumOptions{} } +func (m *EnumOptions) String() string { return proto.CompactTextString(m) } +func (*EnumOptions) ProtoMessage() {} + +var extRange_EnumOptions = []proto.ExtensionRange{ + {1000, 536870911}, +} + +func (*EnumOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_EnumOptions +} +func (m *EnumOptions) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +const Default_EnumOptions_Deprecated bool = false + +func (m *EnumOptions) GetAllowAlias() bool { + if m != nil && m.AllowAlias != nil { + return *m.AllowAlias + } + return false +} + +func (m *EnumOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_EnumOptions_Deprecated +} + +func (m *EnumOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type EnumValueOptions struct { + // Is this enum value deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the enum value, or it will be completely ignored; in the very least, + // this is a formalization for deprecating enum values. + Deprecated *bool `protobuf:"varint,1,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option" json:"uninterpreted_option,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EnumValueOptions) Reset() { *m = EnumValueOptions{} } +func (m *EnumValueOptions) String() string { return proto.CompactTextString(m) } +func (*EnumValueOptions) ProtoMessage() {} + +var extRange_EnumValueOptions = []proto.ExtensionRange{ + {1000, 536870911}, +} + +func (*EnumValueOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_EnumValueOptions +} +func (m *EnumValueOptions) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +const Default_EnumValueOptions_Deprecated bool = false + +func (m *EnumValueOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_EnumValueOptions_Deprecated +} + +func (m *EnumValueOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type ServiceOptions struct { + // Is this service deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the service, or it will be completely ignored; in the very least, + // this is a formalization for deprecating services. + Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option" json:"uninterpreted_option,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ServiceOptions) Reset() { *m = ServiceOptions{} } +func (m *ServiceOptions) String() string { return proto.CompactTextString(m) } +func (*ServiceOptions) ProtoMessage() {} + +var extRange_ServiceOptions = []proto.ExtensionRange{ + {1000, 536870911}, +} + +func (*ServiceOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_ServiceOptions +} +func (m *ServiceOptions) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +const Default_ServiceOptions_Deprecated bool = false + +func (m *ServiceOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_ServiceOptions_Deprecated +} + +func (m *ServiceOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type MethodOptions struct { + // Is this method deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the method, or it will be completely ignored; in the very least, + // this is a formalization for deprecating methods. + Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option" json:"uninterpreted_option,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MethodOptions) Reset() { *m = MethodOptions{} } +func (m *MethodOptions) String() string { return proto.CompactTextString(m) } +func (*MethodOptions) ProtoMessage() {} + +var extRange_MethodOptions = []proto.ExtensionRange{ + {1000, 536870911}, +} + +func (*MethodOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MethodOptions +} +func (m *MethodOptions) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +const Default_MethodOptions_Deprecated bool = false + +func (m *MethodOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_MethodOptions_Deprecated +} + +func (m *MethodOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +// A message representing a option the parser does not recognize. This only +// appears in options protos created by the compiler::Parser class. +// DescriptorPool resolves these when building Descriptor objects. Therefore, +// options protos in descriptor objects (e.g. returned by Descriptor::options(), +// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions +// in them. +type UninterpretedOption struct { + Name []*UninterpretedOption_NamePart `protobuf:"bytes,2,rep,name=name" json:"name,omitempty"` + // The value of the uninterpreted option, in whatever type the tokenizer + // identified it as during parsing. Exactly one of these should be set. + IdentifierValue *string `protobuf:"bytes,3,opt,name=identifier_value" json:"identifier_value,omitempty"` + PositiveIntValue *uint64 `protobuf:"varint,4,opt,name=positive_int_value" json:"positive_int_value,omitempty"` + NegativeIntValue *int64 `protobuf:"varint,5,opt,name=negative_int_value" json:"negative_int_value,omitempty"` + DoubleValue *float64 `protobuf:"fixed64,6,opt,name=double_value" json:"double_value,omitempty"` + StringValue []byte `protobuf:"bytes,7,opt,name=string_value" json:"string_value,omitempty"` + AggregateValue *string `protobuf:"bytes,8,opt,name=aggregate_value" json:"aggregate_value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UninterpretedOption) Reset() { *m = UninterpretedOption{} } +func (m *UninterpretedOption) String() string { return proto.CompactTextString(m) } +func (*UninterpretedOption) ProtoMessage() {} + +func (m *UninterpretedOption) GetName() []*UninterpretedOption_NamePart { + if m != nil { + return m.Name + } + return nil +} + +func (m *UninterpretedOption) GetIdentifierValue() string { + if m != nil && m.IdentifierValue != nil { + return *m.IdentifierValue + } + return "" +} + +func (m *UninterpretedOption) GetPositiveIntValue() uint64 { + if m != nil && m.PositiveIntValue != nil { + return *m.PositiveIntValue + } + return 0 +} + +func (m *UninterpretedOption) GetNegativeIntValue() int64 { + if m != nil && m.NegativeIntValue != nil { + return *m.NegativeIntValue + } + return 0 +} + +func (m *UninterpretedOption) GetDoubleValue() float64 { + if m != nil && m.DoubleValue != nil { + return *m.DoubleValue + } + return 0 +} + +func (m *UninterpretedOption) GetStringValue() []byte { + if m != nil { + return m.StringValue + } + return nil +} + +func (m *UninterpretedOption) GetAggregateValue() string { + if m != nil && m.AggregateValue != nil { + return *m.AggregateValue + } + return "" +} + +// The name of the uninterpreted option. Each string represents a segment in +// a dot-separated name. is_extension is true iff a segment represents an +// extension (denoted with parentheses in options specs in .proto files). +// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents +// "foo.(bar.baz).qux". +type UninterpretedOption_NamePart struct { + NamePart *string `protobuf:"bytes,1,req,name=name_part" json:"name_part,omitempty"` + IsExtension *bool `protobuf:"varint,2,req,name=is_extension" json:"is_extension,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UninterpretedOption_NamePart) Reset() { *m = UninterpretedOption_NamePart{} } +func (m *UninterpretedOption_NamePart) String() string { return proto.CompactTextString(m) } +func (*UninterpretedOption_NamePart) ProtoMessage() {} + +func (m *UninterpretedOption_NamePart) GetNamePart() string { + if m != nil && m.NamePart != nil { + return *m.NamePart + } + return "" +} + +func (m *UninterpretedOption_NamePart) GetIsExtension() bool { + if m != nil && m.IsExtension != nil { + return *m.IsExtension + } + return false +} + +// Encapsulates information about the original source file from which a +// FileDescriptorProto was generated. +type SourceCodeInfo struct { + // A Location identifies a piece of source code in a .proto file which + // corresponds to a particular definition. This information is intended + // to be useful to IDEs, code indexers, documentation generators, and similar + // tools. + // + // For example, say we have a file like: + // message Foo { + // optional string foo = 1; + // } + // Let's look at just the field definition: + // optional string foo = 1; + // ^ ^^ ^^ ^ ^^^ + // a bc de f ghi + // We have the following locations: + // span path represents + // [a,i) [ 4, 0, 2, 0 ] The whole field definition. + // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). + // [c,d) [ 4, 0, 2, 0, 5 ] The type (string). + // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). + // [g,h) [ 4, 0, 2, 0, 3 ] The number (1). + // + // Notes: + // - A location may refer to a repeated field itself (i.e. not to any + // particular index within it). This is used whenever a set of elements are + // logically enclosed in a single code segment. For example, an entire + // extend block (possibly containing multiple extension definitions) will + // have an outer location whose path refers to the "extensions" repeated + // field without an index. + // - Multiple locations may have the same path. This happens when a single + // logical declaration is spread out across multiple places. The most + // obvious example is the "extend" block again -- there may be multiple + // extend blocks in the same scope, each of which will have the same path. + // - A location's span is not always a subset of its parent's span. For + // example, the "extendee" of an extension declaration appears at the + // beginning of the "extend" block and is shared by all extensions within + // the block. + // - Just because a location's span is a subset of some other location's span + // does not mean that it is a descendent. For example, a "group" defines + // both a type and a field in a single declaration. Thus, the locations + // corresponding to the type and field and their components will overlap. + // - Code which tries to interpret locations should probably be designed to + // ignore those that it doesn't understand, as more types of locations could + // be recorded in the future. + Location []*SourceCodeInfo_Location `protobuf:"bytes,1,rep,name=location" json:"location,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SourceCodeInfo) Reset() { *m = SourceCodeInfo{} } +func (m *SourceCodeInfo) String() string { return proto.CompactTextString(m) } +func (*SourceCodeInfo) ProtoMessage() {} + +func (m *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location { + if m != nil { + return m.Location + } + return nil +} + +type SourceCodeInfo_Location struct { + // Identifies which part of the FileDescriptorProto was defined at this + // location. + // + // Each element is a field number or an index. They form a path from + // the root FileDescriptorProto to the place where the definition. For + // example, this path: + // [ 4, 3, 2, 7, 1 ] + // refers to: + // file.message_type(3) // 4, 3 + // .field(7) // 2, 7 + // .name() // 1 + // This is because FileDescriptorProto.message_type has field number 4: + // repeated DescriptorProto message_type = 4; + // and DescriptorProto.field has field number 2: + // repeated FieldDescriptorProto field = 2; + // and FieldDescriptorProto.name has field number 1: + // optional string name = 1; + // + // Thus, the above path gives the location of a field name. If we removed + // the last element: + // [ 4, 3, 2, 7 ] + // this path refers to the whole field declaration (from the beginning + // of the label to the terminating semicolon). + Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"` + // Always has exactly three or four elements: start line, start column, + // end line (optional, otherwise assumed same as start line), end column. + // These are packed into a single field for efficiency. Note that line + // and column numbers are zero-based -- typically you will want to add + // 1 to each before displaying to a user. + Span []int32 `protobuf:"varint,2,rep,packed,name=span" json:"span,omitempty"` + // If this SourceCodeInfo represents a complete declaration, these are any + // comments appearing before and after the declaration which appear to be + // attached to the declaration. + // + // A series of line comments appearing on consecutive lines, with no other + // tokens appearing on those lines, will be treated as a single comment. + // + // Only the comment content is provided; comment markers (e.g. //) are + // stripped out. For block comments, leading whitespace and an asterisk + // will be stripped from the beginning of each line other than the first. + // Newlines are included in the output. + // + // Examples: + // + // optional int32 foo = 1; // Comment attached to foo. + // // Comment attached to bar. + // optional int32 bar = 2; + // + // optional string baz = 3; + // // Comment attached to baz. + // // Another line attached to baz. + // + // // Comment attached to qux. + // // + // // Another line attached to qux. + // optional double qux = 4; + // + // optional string corge = 5; + // /* Block comment attached + // * to corge. Leading asterisks + // * will be removed. */ + // /* Block comment attached to + // * grault. */ + // optional int32 grault = 6; + LeadingComments *string `protobuf:"bytes,3,opt,name=leading_comments" json:"leading_comments,omitempty"` + TrailingComments *string `protobuf:"bytes,4,opt,name=trailing_comments" json:"trailing_comments,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SourceCodeInfo_Location) Reset() { *m = SourceCodeInfo_Location{} } +func (m *SourceCodeInfo_Location) String() string { return proto.CompactTextString(m) } +func (*SourceCodeInfo_Location) ProtoMessage() {} + +func (m *SourceCodeInfo_Location) GetPath() []int32 { + if m != nil { + return m.Path + } + return nil +} + +func (m *SourceCodeInfo_Location) GetSpan() []int32 { + if m != nil { + return m.Span + } + return nil +} + +func (m *SourceCodeInfo_Location) GetLeadingComments() string { + if m != nil && m.LeadingComments != nil { + return *m.LeadingComments + } + return "" +} + +func (m *SourceCodeInfo_Location) GetTrailingComments() string { + if m != nil && m.TrailingComments != nil { + return *m.TrailingComments + } + return "" +} + +func init() { + proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Type", FieldDescriptorProto_Type_name, FieldDescriptorProto_Type_value) + proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Label", FieldDescriptorProto_Label_name, FieldDescriptorProto_Label_value) + proto.RegisterEnum("google.protobuf.FileOptions_OptimizeMode", FileOptions_OptimizeMode_name, FileOptions_OptimizeMode_value) + proto.RegisterEnum("google.protobuf.FieldOptions_CType", FieldOptions_CType_name, FieldOptions_CType_value) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor/gostring.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor/gostring.go new file mode 100644 index 0000000000000000000000000000000000000000..6f79ad9f67a2374dc3ae98458d32fe027d271402 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor/gostring.go @@ -0,0 +1,592 @@ +package google_protobuf + +import fmt "fmt" +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +func (this *FileDescriptorSet) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&google_protobuf.FileDescriptorSet{") + if this.File != nil { + s = append(s, "File: "+fmt.Sprintf("%#v", this.File)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FileDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 16) + s = append(s, "&google_protobuf.FileDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Package != nil { + s = append(s, "Package: "+valueToGoStringDescriptor(this.Package, "string")+",\n") + } + if this.Dependency != nil { + s = append(s, "Dependency: "+fmt.Sprintf("%#v", this.Dependency)+",\n") + } + if this.PublicDependency != nil { + s = append(s, "PublicDependency: "+fmt.Sprintf("%#v", this.PublicDependency)+",\n") + } + if this.WeakDependency != nil { + s = append(s, "WeakDependency: "+fmt.Sprintf("%#v", this.WeakDependency)+",\n") + } + if this.MessageType != nil { + s = append(s, "MessageType: "+fmt.Sprintf("%#v", this.MessageType)+",\n") + } + if this.EnumType != nil { + s = append(s, "EnumType: "+fmt.Sprintf("%#v", this.EnumType)+",\n") + } + if this.Service != nil { + s = append(s, "Service: "+fmt.Sprintf("%#v", this.Service)+",\n") + } + if this.Extension != nil { + s = append(s, "Extension: "+fmt.Sprintf("%#v", this.Extension)+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.SourceCodeInfo != nil { + s = append(s, "SourceCodeInfo: "+fmt.Sprintf("%#v", this.SourceCodeInfo)+",\n") + } + if this.Syntax != nil { + s = append(s, "Syntax: "+valueToGoStringDescriptor(this.Syntax, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 12) + s = append(s, "&google_protobuf.DescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Field != nil { + s = append(s, "Field: "+fmt.Sprintf("%#v", this.Field)+",\n") + } + if this.Extension != nil { + s = append(s, "Extension: "+fmt.Sprintf("%#v", this.Extension)+",\n") + } + if this.NestedType != nil { + s = append(s, "NestedType: "+fmt.Sprintf("%#v", this.NestedType)+",\n") + } + if this.EnumType != nil { + s = append(s, "EnumType: "+fmt.Sprintf("%#v", this.EnumType)+",\n") + } + if this.ExtensionRange != nil { + s = append(s, "ExtensionRange: "+fmt.Sprintf("%#v", this.ExtensionRange)+",\n") + } + if this.OneofDecl != nil { + s = append(s, "OneofDecl: "+fmt.Sprintf("%#v", this.OneofDecl)+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DescriptorProto_ExtensionRange) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&google_protobuf.DescriptorProto_ExtensionRange{") + if this.Start != nil { + s = append(s, "Start: "+valueToGoStringDescriptor(this.Start, "int32")+",\n") + } + if this.End != nil { + s = append(s, "End: "+valueToGoStringDescriptor(this.End, "int32")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FieldDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 13) + s = append(s, "&google_protobuf.FieldDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Number != nil { + s = append(s, "Number: "+valueToGoStringDescriptor(this.Number, "int32")+",\n") + } + if this.Label != nil { + s = append(s, "Label: "+valueToGoStringDescriptor(this.Label, "google_protobuf.FieldDescriptorProto_Label")+",\n") + } + if this.Type != nil { + s = append(s, "Type: "+valueToGoStringDescriptor(this.Type, "google_protobuf.FieldDescriptorProto_Type")+",\n") + } + if this.TypeName != nil { + s = append(s, "TypeName: "+valueToGoStringDescriptor(this.TypeName, "string")+",\n") + } + if this.Extendee != nil { + s = append(s, "Extendee: "+valueToGoStringDescriptor(this.Extendee, "string")+",\n") + } + if this.DefaultValue != nil { + s = append(s, "DefaultValue: "+valueToGoStringDescriptor(this.DefaultValue, "string")+",\n") + } + if this.OneofIndex != nil { + s = append(s, "OneofIndex: "+valueToGoStringDescriptor(this.OneofIndex, "int32")+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OneofDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&google_protobuf.OneofDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *EnumDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&google_protobuf.EnumDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *EnumValueDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&google_protobuf.EnumValueDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Number != nil { + s = append(s, "Number: "+valueToGoStringDescriptor(this.Number, "int32")+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *ServiceDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&google_protobuf.ServiceDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.Method != nil { + s = append(s, "Method: "+fmt.Sprintf("%#v", this.Method)+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MethodDescriptorProto) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 10) + s = append(s, "&google_protobuf.MethodDescriptorProto{") + if this.Name != nil { + s = append(s, "Name: "+valueToGoStringDescriptor(this.Name, "string")+",\n") + } + if this.InputType != nil { + s = append(s, "InputType: "+valueToGoStringDescriptor(this.InputType, "string")+",\n") + } + if this.OutputType != nil { + s = append(s, "OutputType: "+valueToGoStringDescriptor(this.OutputType, "string")+",\n") + } + if this.Options != nil { + s = append(s, "Options: "+fmt.Sprintf("%#v", this.Options)+",\n") + } + if this.ClientStreaming != nil { + s = append(s, "ClientStreaming: "+valueToGoStringDescriptor(this.ClientStreaming, "bool")+",\n") + } + if this.ServerStreaming != nil { + s = append(s, "ServerStreaming: "+valueToGoStringDescriptor(this.ServerStreaming, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FileOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 17) + s = append(s, "&google_protobuf.FileOptions{") + if this.JavaPackage != nil { + s = append(s, "JavaPackage: "+valueToGoStringDescriptor(this.JavaPackage, "string")+",\n") + } + if this.JavaOuterClassname != nil { + s = append(s, "JavaOuterClassname: "+valueToGoStringDescriptor(this.JavaOuterClassname, "string")+",\n") + } + if this.JavaMultipleFiles != nil { + s = append(s, "JavaMultipleFiles: "+valueToGoStringDescriptor(this.JavaMultipleFiles, "bool")+",\n") + } + if this.JavaGenerateEqualsAndHash != nil { + s = append(s, "JavaGenerateEqualsAndHash: "+valueToGoStringDescriptor(this.JavaGenerateEqualsAndHash, "bool")+",\n") + } + if this.JavaStringCheckUtf8 != nil { + s = append(s, "JavaStringCheckUtf8: "+valueToGoStringDescriptor(this.JavaStringCheckUtf8, "bool")+",\n") + } + if this.OptimizeFor != nil { + s = append(s, "OptimizeFor: "+valueToGoStringDescriptor(this.OptimizeFor, "google_protobuf.FileOptions_OptimizeMode")+",\n") + } + if this.GoPackage != nil { + s = append(s, "GoPackage: "+valueToGoStringDescriptor(this.GoPackage, "string")+",\n") + } + if this.CcGenericServices != nil { + s = append(s, "CcGenericServices: "+valueToGoStringDescriptor(this.CcGenericServices, "bool")+",\n") + } + if this.JavaGenericServices != nil { + s = append(s, "JavaGenericServices: "+valueToGoStringDescriptor(this.JavaGenericServices, "bool")+",\n") + } + if this.PyGenericServices != nil { + s = append(s, "PyGenericServices: "+valueToGoStringDescriptor(this.PyGenericServices, "bool")+",\n") + } + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.CcEnableArenas != nil { + s = append(s, "CcEnableArenas: "+valueToGoStringDescriptor(this.CcEnableArenas, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringDescriptor(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MessageOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 9) + s = append(s, "&google_protobuf.MessageOptions{") + if this.MessageSetWireFormat != nil { + s = append(s, "MessageSetWireFormat: "+valueToGoStringDescriptor(this.MessageSetWireFormat, "bool")+",\n") + } + if this.NoStandardDescriptorAccessor != nil { + s = append(s, "NoStandardDescriptorAccessor: "+valueToGoStringDescriptor(this.NoStandardDescriptorAccessor, "bool")+",\n") + } + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.MapEntry != nil { + s = append(s, "MapEntry: "+valueToGoStringDescriptor(this.MapEntry, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringDescriptor(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FieldOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 10) + s = append(s, "&google_protobuf.FieldOptions{") + if this.Ctype != nil { + s = append(s, "Ctype: "+valueToGoStringDescriptor(this.Ctype, "google_protobuf.FieldOptions_CType")+",\n") + } + if this.Packed != nil { + s = append(s, "Packed: "+valueToGoStringDescriptor(this.Packed, "bool")+",\n") + } + if this.Lazy != nil { + s = append(s, "Lazy: "+valueToGoStringDescriptor(this.Lazy, "bool")+",\n") + } + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.Weak != nil { + s = append(s, "Weak: "+valueToGoStringDescriptor(this.Weak, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringDescriptor(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *EnumOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&google_protobuf.EnumOptions{") + if this.AllowAlias != nil { + s = append(s, "AllowAlias: "+valueToGoStringDescriptor(this.AllowAlias, "bool")+",\n") + } + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringDescriptor(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *EnumValueOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&google_protobuf.EnumValueOptions{") + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringDescriptor(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *ServiceOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&google_protobuf.ServiceOptions{") + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringDescriptor(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MethodOptions) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&google_protobuf.MethodOptions{") + if this.Deprecated != nil { + s = append(s, "Deprecated: "+valueToGoStringDescriptor(this.Deprecated, "bool")+",\n") + } + if this.UninterpretedOption != nil { + s = append(s, "UninterpretedOption: "+fmt.Sprintf("%#v", this.UninterpretedOption)+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringDescriptor(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UninterpretedOption) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 11) + s = append(s, "&google_protobuf.UninterpretedOption{") + if this.Name != nil { + s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n") + } + if this.IdentifierValue != nil { + s = append(s, "IdentifierValue: "+valueToGoStringDescriptor(this.IdentifierValue, "string")+",\n") + } + if this.PositiveIntValue != nil { + s = append(s, "PositiveIntValue: "+valueToGoStringDescriptor(this.PositiveIntValue, "uint64")+",\n") + } + if this.NegativeIntValue != nil { + s = append(s, "NegativeIntValue: "+valueToGoStringDescriptor(this.NegativeIntValue, "int64")+",\n") + } + if this.DoubleValue != nil { + s = append(s, "DoubleValue: "+valueToGoStringDescriptor(this.DoubleValue, "float64")+",\n") + } + if this.StringValue != nil { + s = append(s, "StringValue: "+valueToGoStringDescriptor(this.StringValue, "byte")+",\n") + } + if this.AggregateValue != nil { + s = append(s, "AggregateValue: "+valueToGoStringDescriptor(this.AggregateValue, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UninterpretedOption_NamePart) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&google_protobuf.UninterpretedOption_NamePart{") + if this.NamePart != nil { + s = append(s, "NamePart: "+valueToGoStringDescriptor(this.NamePart, "string")+",\n") + } + if this.IsExtension != nil { + s = append(s, "IsExtension: "+valueToGoStringDescriptor(this.IsExtension, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SourceCodeInfo) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&google_protobuf.SourceCodeInfo{") + if this.Location != nil { + s = append(s, "Location: "+fmt.Sprintf("%#v", this.Location)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SourceCodeInfo_Location) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&google_protobuf.SourceCodeInfo_Location{") + if this.Path != nil { + s = append(s, "Path: "+fmt.Sprintf("%#v", this.Path)+",\n") + } + if this.Span != nil { + s = append(s, "Span: "+fmt.Sprintf("%#v", this.Span)+",\n") + } + if this.LeadingComments != nil { + s = append(s, "LeadingComments: "+valueToGoStringDescriptor(this.LeadingComments, "string")+",\n") + } + if this.TrailingComments != nil { + s = append(s, "TrailingComments: "+valueToGoStringDescriptor(this.TrailingComments, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringDescriptor(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringDescriptor(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor/helper.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor/helper.go new file mode 100644 index 0000000000000000000000000000000000000000..ad0c1e907e3af5d59c3845d863b170a6fbf9a3e8 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor/helper.go @@ -0,0 +1,342 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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 google_protobuf + +import ( + "strings" +) + +func (msg *DescriptorProto) GetMapFields() (*FieldDescriptorProto, *FieldDescriptorProto) { + if !msg.GetOptions().GetMapEntry() { + return nil, nil + } + return msg.GetField()[0], msg.GetField()[1] +} + +func dotToUnderscore(r rune) rune { + if r == '.' { + return '_' + } + return r +} + +func (field *FieldDescriptorProto) WireType() (wire int) { + switch *field.Type { + case FieldDescriptorProto_TYPE_DOUBLE: + return 1 + case FieldDescriptorProto_TYPE_FLOAT: + return 5 + case FieldDescriptorProto_TYPE_INT64: + return 0 + case FieldDescriptorProto_TYPE_UINT64: + return 0 + case FieldDescriptorProto_TYPE_INT32: + return 0 + case FieldDescriptorProto_TYPE_UINT32: + return 0 + case FieldDescriptorProto_TYPE_FIXED64: + return 1 + case FieldDescriptorProto_TYPE_FIXED32: + return 5 + case FieldDescriptorProto_TYPE_BOOL: + return 0 + case FieldDescriptorProto_TYPE_STRING: + return 2 + case FieldDescriptorProto_TYPE_GROUP: + return 2 + case FieldDescriptorProto_TYPE_MESSAGE: + return 2 + case FieldDescriptorProto_TYPE_BYTES: + return 2 + case FieldDescriptorProto_TYPE_ENUM: + return 0 + case FieldDescriptorProto_TYPE_SFIXED32: + return 5 + case FieldDescriptorProto_TYPE_SFIXED64: + return 1 + case FieldDescriptorProto_TYPE_SINT32: + return 0 + case FieldDescriptorProto_TYPE_SINT64: + return 0 + } + panic("unreachable") +} + +func (field *FieldDescriptorProto) GetKeyUint64() (x uint64) { + packed := field.IsPacked() + wireType := field.WireType() + fieldNumber := field.GetNumber() + if packed { + wireType = 2 + } + x = uint64(uint32(fieldNumber)<<3 | uint32(wireType)) + return x +} + +func (field *FieldDescriptorProto) GetKey() []byte { + x := field.GetKeyUint64() + i := 0 + keybuf := make([]byte, 0) + for i = 0; x > 127; i++ { + keybuf = append(keybuf, 0x80|uint8(x&0x7F)) + x >>= 7 + } + keybuf = append(keybuf, uint8(x)) + return keybuf +} + +func (desc *FileDescriptorSet) GetField(packageName, messageName, fieldName string) *FieldDescriptorProto { + msg := desc.GetMessage(packageName, messageName) + if msg == nil { + return nil + } + for _, field := range msg.GetField() { + if field.GetName() == fieldName { + return field + } + } + return nil +} + +func (file *FileDescriptorProto) GetMessage(typeName string) *DescriptorProto { + for _, msg := range file.GetMessageType() { + if msg.GetName() == typeName { + return msg + } + for _, nes := range msg.GetNestedType() { + if nes.GetName() == typeName { + return nes + } + if msg.GetName()+"."+nes.GetName() == typeName { + return nes + } + } + } + return nil +} + +func (desc *FileDescriptorSet) GetMessage(packageName string, typeName string) *DescriptorProto { + for _, file := range desc.GetFile() { + if strings.Map(dotToUnderscore, file.GetPackage()) != strings.Map(dotToUnderscore, packageName) { + continue + } + for _, msg := range file.GetMessageType() { + if msg.GetName() == typeName { + return msg + } + } + for _, msg := range file.GetMessageType() { + for _, nes := range msg.GetNestedType() { + if nes.GetName() == typeName { + return nes + } + if msg.GetName()+"."+nes.GetName() == typeName { + return nes + } + } + } + } + return nil +} + +func (desc *FileDescriptorSet) IsProto3(packageName string, typeName string) bool { + for _, file := range desc.GetFile() { + if strings.Map(dotToUnderscore, file.GetPackage()) != strings.Map(dotToUnderscore, packageName) { + continue + } + for _, msg := range file.GetMessageType() { + if msg.GetName() == typeName { + return file.GetSyntax() == "proto3" + } + } + for _, msg := range file.GetMessageType() { + for _, nes := range msg.GetNestedType() { + if nes.GetName() == typeName { + return file.GetSyntax() == "proto3" + } + if msg.GetName()+"."+nes.GetName() == typeName { + return file.GetSyntax() == "proto3" + } + } + } + } + return false +} + +func (msg *DescriptorProto) IsExtendable() bool { + return len(msg.GetExtensionRange()) > 0 +} + +func (desc *FileDescriptorSet) FindExtension(packageName string, typeName string, fieldName string) (extPackageName string, field *FieldDescriptorProto) { + parent := desc.GetMessage(packageName, typeName) + if parent == nil { + return "", nil + } + if !parent.IsExtendable() { + return "", nil + } + extendee := "." + packageName + "." + typeName + for _, file := range desc.GetFile() { + for _, ext := range file.GetExtension() { + if strings.Map(dotToUnderscore, file.GetPackage()) == strings.Map(dotToUnderscore, packageName) { + if !(ext.GetExtendee() == typeName || ext.GetExtendee() == extendee) { + continue + } + } else { + if ext.GetExtendee() != extendee { + continue + } + } + if ext.GetName() == fieldName { + return file.GetPackage(), ext + } + } + } + return "", nil +} + +func (desc *FileDescriptorSet) FindExtensionByFieldNumber(packageName string, typeName string, fieldNum int32) (extPackageName string, field *FieldDescriptorProto) { + parent := desc.GetMessage(packageName, typeName) + if parent == nil { + return "", nil + } + if !parent.IsExtendable() { + return "", nil + } + extendee := "." + packageName + "." + typeName + for _, file := range desc.GetFile() { + for _, ext := range file.GetExtension() { + if strings.Map(dotToUnderscore, file.GetPackage()) == strings.Map(dotToUnderscore, packageName) { + if !(ext.GetExtendee() == typeName || ext.GetExtendee() == extendee) { + continue + } + } else { + if ext.GetExtendee() != extendee { + continue + } + } + if ext.GetNumber() == fieldNum { + return file.GetPackage(), ext + } + } + } + return "", nil +} + +func (desc *FileDescriptorSet) FindMessage(packageName string, typeName string, fieldName string) (msgPackageName string, msgName string) { + parent := desc.GetMessage(packageName, typeName) + if parent == nil { + return "", "" + } + field := parent.GetFieldDescriptor(fieldName) + if field == nil { + var extPackageName string + extPackageName, field = desc.FindExtension(packageName, typeName, fieldName) + if field == nil { + return "", "" + } + packageName = extPackageName + } + typeNames := strings.Split(field.GetTypeName(), ".") + if len(typeNames) == 1 { + msg := desc.GetMessage(packageName, typeName) + if msg == nil { + return "", "" + } + return packageName, msg.GetName() + } + if len(typeNames) > 2 { + for i := 1; i < len(typeNames)-1; i++ { + packageName = strings.Join(typeNames[1:len(typeNames)-i], ".") + typeName = strings.Join(typeNames[len(typeNames)-i:], ".") + msg := desc.GetMessage(packageName, typeName) + if msg != nil { + typeNames := strings.Split(msg.GetName(), ".") + if len(typeNames) == 1 { + return packageName, msg.GetName() + } + return strings.Join(typeNames[1:len(typeNames)-1], "."), typeNames[len(typeNames)-1] + } + } + } + return "", "" +} + +func (msg *DescriptorProto) GetFieldDescriptor(fieldName string) *FieldDescriptorProto { + for _, field := range msg.GetField() { + if field.GetName() == fieldName { + return field + } + } + return nil +} + +func (desc *FileDescriptorSet) GetEnum(packageName string, typeName string) *EnumDescriptorProto { + for _, file := range desc.GetFile() { + if strings.Map(dotToUnderscore, file.GetPackage()) != strings.Map(dotToUnderscore, packageName) { + continue + } + for _, enum := range file.GetEnumType() { + if enum.GetName() == typeName { + return enum + } + } + } + return nil +} + +func (f *FieldDescriptorProto) IsEnum() bool { + return *f.Type == FieldDescriptorProto_TYPE_ENUM +} + +func (f *FieldDescriptorProto) IsMessage() bool { + return *f.Type == FieldDescriptorProto_TYPE_MESSAGE +} + +func (f *FieldDescriptorProto) IsBytes() bool { + return *f.Type == FieldDescriptorProto_TYPE_BYTES +} + +func (f *FieldDescriptorProto) IsRepeated() bool { + return f.Label != nil && *f.Label == FieldDescriptorProto_LABEL_REPEATED +} + +func (f *FieldDescriptorProto) IsString() bool { + return *f.Type == FieldDescriptorProto_TYPE_STRING +} + +func (f *FieldDescriptorProto) IsRequired() bool { + return f.Label != nil && *f.Label == FieldDescriptorProto_LABEL_REQUIRED +} + +func (f *FieldDescriptorProto) IsPacked() bool { + return f.Options != nil && f.GetOptions().GetPacked() +} + +func (m *DescriptorProto) HasExtension() bool { + return len(m.ExtensionRange) > 0 +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/doc.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/doc.go new file mode 100644 index 0000000000000000000000000000000000000000..15c7cf43c282caa435aa34024a8d057a89943c00 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/doc.go @@ -0,0 +1,51 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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. + +/* + A plugin for the Google protocol buffer compiler to generate Go code. + Run it by building this program and putting it in your path with the name + protoc-gen-gogo + That word 'gogo' at the end becomes part of the option string set for the + protocol compiler, so once the protocol compiler (protoc) is installed + you can run + protoc --gogo_out=output_directory input_directory/file.proto + to generate Go bindings for the protocol defined by file.proto. + With that input, the output will be written to + output_directory/go_package/file.pb.go + + The generated code is documented in the package comment for + the library. + + See the README and documentation for protocol buffers to learn more: + https://developers.google.com/protocol-buffers/ + +*/ +package documentation diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator/generator.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator/generator.go new file mode 100644 index 0000000000000000000000000000000000000000..de90c4e3b71bd4b9660fa69bbad2dfcf5cf4ce38 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator/generator.go @@ -0,0 +1,2785 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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. + +/* + The code generator for the plugin for the Google protocol buffer compiler. + It generates Go code from the protocol buffer description files read by the + main routine. +*/ +package generator + +import ( + "bufio" + "bytes" + "fmt" + "go/parser" + "go/printer" + "go/token" + "log" + "os" + "path" + "sort" + "strconv" + "strings" + "unicode" + "unicode/utf8" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + descriptor "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + plugin "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/plugin" +) + +// A Plugin provides functionality to add to the output during Go code generation, +// such as to produce RPC stubs. +type Plugin interface { + // Name identifies the plugin. + Name() string + // Init is called once after data structures are built but before + // code generation begins. + Init(g *Generator) + // Generate produces the code generated by the plugin for this file, + // except for the imports, by calling the generator's methods P, In, and Out. + Generate(file *FileDescriptor) + // GenerateImports produces the import declarations for this file. + // It is called after Generate. + GenerateImports(file *FileDescriptor) +} + +type pluginSlice []Plugin + +func (ps pluginSlice) Len() int { + return len(ps) +} + +func (ps pluginSlice) Less(i, j int) bool { + return ps[i].Name() < ps[j].Name() +} + +func (ps pluginSlice) Swap(i, j int) { + ps[i], ps[j] = ps[j], ps[i] +} + +var plugins pluginSlice + +// RegisterPlugin installs a (second-order) plugin to be run when the Go output is generated. +// It is typically called during initialization. +func RegisterPlugin(p Plugin) { + plugins = append(plugins, p) +} + +// Each type we import as a protocol buffer (other than FileDescriptorProto) needs +// a pointer to the FileDescriptorProto that represents it. These types achieve that +// wrapping by placing each Proto inside a struct with the pointer to its File. The +// structs have the same names as their contents, with "Proto" removed. +// FileDescriptor is used to store the things that it points to. + +// The file and package name method are common to messages and enums. +type common struct { + file *descriptor.FileDescriptorProto // File this object comes from. +} + +// PackageName is name in the package clause in the generated file. +func (c *common) PackageName() string { return uniquePackageOf(c.file) } + +func (c *common) File() *descriptor.FileDescriptorProto { return c.file } + +func fileIsProto3(file *descriptor.FileDescriptorProto) bool { + return file.GetSyntax() == "proto3" +} + +func (c *common) proto3() bool { return fileIsProto3(c.file) } + +// Descriptor represents a protocol buffer message. +type Descriptor struct { + common + *descriptor.DescriptorProto + parent *Descriptor // The containing message, if any. + nested []*Descriptor // Inner messages, if any. + enums []*EnumDescriptor // Inner enums, if any. + ext []*ExtensionDescriptor // Extensions, if any. + typename []string // Cached typename vector. + index int // The index into the container, whether the file or another message. + path string // The SourceCodeInfo path as comma-separated integers. + group bool +} + +// TypeName returns the elements of the dotted type name. +// The package name is not part of this name. +func (d *Descriptor) TypeName() []string { + if d.typename != nil { + return d.typename + } + n := 0 + for parent := d; parent != nil; parent = parent.parent { + n++ + } + s := make([]string, n, n) + for parent := d; parent != nil; parent = parent.parent { + n-- + s[n] = parent.GetName() + } + d.typename = s + return s +} + +func (d *Descriptor) allowOneof() bool { + return true +} + +// EnumDescriptor describes an enum. If it's at top level, its parent will be nil. +// Otherwise it will be the descriptor of the message in which it is defined. +type EnumDescriptor struct { + common + *descriptor.EnumDescriptorProto + parent *Descriptor // The containing message, if any. + typename []string // Cached typename vector. + index int // The index into the container, whether the file or a message. + path string // The SourceCodeInfo path as comma-separated integers. +} + +// TypeName returns the elements of the dotted type name. +// The package name is not part of this name. +func (e *EnumDescriptor) TypeName() (s []string) { + if e.typename != nil { + return e.typename + } + name := e.GetName() + if e.parent == nil { + s = make([]string, 1) + } else { + pname := e.parent.TypeName() + s = make([]string, len(pname)+1) + copy(s, pname) + } + s[len(s)-1] = name + e.typename = s + return s +} + +// Everything but the last element of the full type name, CamelCased. +// The values of type Foo.Bar are call Foo_value1... not Foo_Bar_value1... . +func (e *EnumDescriptor) prefix() string { + if e.parent == nil { + // If the enum is not part of a message, the prefix is just the type name. + return CamelCase(*e.Name) + "_" + } + typeName := e.TypeName() + return CamelCaseSlice(typeName[0:len(typeName)-1]) + "_" +} + +// The integer value of the named constant in this enumerated type. +func (e *EnumDescriptor) integerValueAsString(name string) string { + for _, c := range e.Value { + if c.GetName() == name { + return fmt.Sprint(c.GetNumber()) + } + } + log.Fatal("cannot find value for enum constant") + return "" +} + +// ExtensionDescriptor describes an extension. If it's at top level, its parent will be nil. +// Otherwise it will be the descriptor of the message in which it is defined. +type ExtensionDescriptor struct { + common + *descriptor.FieldDescriptorProto + parent *Descriptor // The containing message, if any. +} + +// TypeName returns the elements of the dotted type name. +// The package name is not part of this name. +func (e *ExtensionDescriptor) TypeName() (s []string) { + name := e.GetName() + if e.parent == nil { + // top-level extension + s = make([]string, 1) + } else { + pname := e.parent.TypeName() + s = make([]string, len(pname)+1) + copy(s, pname) + } + s[len(s)-1] = name + return s +} + +// DescName returns the variable name used for the generated descriptor. +func (e *ExtensionDescriptor) DescName() string { + // The full type name. + typeName := e.TypeName() + // Each scope of the extension is individually CamelCased, and all are joined with "_" with an "E_" prefix. + for i, s := range typeName { + typeName[i] = CamelCase(s) + } + return "E_" + strings.Join(typeName, "_") +} + +// ImportedDescriptor describes a type that has been publicly imported from another file. +type ImportedDescriptor struct { + common + o Object +} + +func (id *ImportedDescriptor) TypeName() []string { return id.o.TypeName() } + +// FileDescriptor describes an protocol buffer descriptor file (.proto). +// It includes slices of all the messages and enums defined within it. +// Those slices are constructed by WrapTypes. +type FileDescriptor struct { + *descriptor.FileDescriptorProto + desc []*Descriptor // All the messages defined in this file. + enum []*EnumDescriptor // All the enums defined in this file. + ext []*ExtensionDescriptor // All the top-level extensions defined in this file. + imp []*ImportedDescriptor // All types defined in files publicly imported by this file. + + // Comments, stored as a map of path (comma-separated integers) to the comment. + comments map[string]*descriptor.SourceCodeInfo_Location + + // The full list of symbols that are exported, + // as a map from the exported object to its symbols. + // This is used for supporting public imports. + exported map[Object][]symbol + + index int // The index of this file in the list of files to generate code for + + proto3 bool // whether to generate proto3 code for this file +} + +// PackageName is the package name we'll use in the generated code to refer to this file. +func (d *FileDescriptor) PackageName() string { return uniquePackageOf(d.FileDescriptorProto) } + +// goPackageName returns the Go package name to use in the +// generated Go file. The result explicit reports whether the name +// came from an option go_package statement. If explicit is false, +// the name was derived from the protocol buffer's package statement +// or the input file name. +func (d *FileDescriptor) goPackageName() (name string, explicit bool) { + // Does the file have a "go_package" option? + if opts := d.Options; opts != nil { + if pkg := opts.GetGoPackage(); pkg != "" { + return pkg, true + } + } + + // Does the file have a package clause? + if pkg := d.GetPackage(); pkg != "" { + return pkg, false + } + // Use the file base name. + return baseName(d.GetName()), false +} + +func (d *FileDescriptor) addExport(obj Object, sym symbol) { + d.exported[obj] = append(d.exported[obj], sym) +} + +// symbol is an interface representing an exported Go symbol. +type symbol interface { + // GenerateAlias should generate an appropriate alias + // for the symbol from the named package. + GenerateAlias(g *Generator, pkg string) +} + +type messageSymbol struct { + sym string + hasExtensions, isMessageSet bool + getters []getterSymbol +} + +type getterSymbol struct { + name string + typ string + typeName string // canonical name in proto world; empty for proto.Message and similar + genType bool // whether typ contains a generated type (message/group/enum) +} + +func (ms *messageSymbol) GenerateAlias(g *Generator, pkg string) { + remoteSym := pkg + "." + ms.sym + + g.P("type ", ms.sym, " ", remoteSym) + g.P("func (m *", ms.sym, ") Reset() { (*", remoteSym, ")(m).Reset() }") + g.P("func (m *", ms.sym, ") String() string { return (*", remoteSym, ")(m).String() }") + g.P("func (*", ms.sym, ") ProtoMessage() {}") + if ms.hasExtensions { + g.P("func (*", ms.sym, ") ExtensionRangeArray() []", g.Pkg["proto"], ".ExtensionRange ", + "{ return (*", remoteSym, ")(nil).ExtensionRangeArray() }") + g.P("func (m *", ms.sym, ") ExtensionMap() map[int32]", g.Pkg["proto"], ".Extension ", + "{ return (*", remoteSym, ")(m).ExtensionMap() }") + if ms.isMessageSet { + g.P("func (m *", ms.sym, ") Marshal() ([]byte, error) ", + "{ return (*", remoteSym, ")(m).Marshal() }") + g.P("func (m *", ms.sym, ") Unmarshal(buf []byte) error ", + "{ return (*", remoteSym, ")(m).Unmarshal(buf) }") + } + } + for _, get := range ms.getters { + + if get.typeName != "" { + g.RecordTypeUse(get.typeName) + } + typ := get.typ + val := "(*" + remoteSym + ")(m)." + get.name + "()" + if get.genType { + // typ will be "*pkg.T" (message/group) or "pkg.T" (enum) + // or "map[t]*pkg.T" (map to message/enum). + // The first two of those might have a "[]" prefix if it is repeated. + // Drop any package qualifier since we have hoisted the type into this package. + rep := strings.HasPrefix(typ, "[]") + if rep { + typ = typ[2:] + } + isMap := strings.HasPrefix(typ, "map[") + star := typ[0] == '*' + if !isMap { // map types handled lower down + typ = typ[strings.Index(typ, ".")+1:] + } + if star { + typ = "*" + typ + } + if rep { + // Go does not permit conversion between slice types where both + // element types are named. That means we need to generate a bit + // of code in this situation. + // typ is the element type. + // val is the expression to get the slice from the imported type. + + ctyp := typ // conversion type expression; "Foo" or "(*Foo)" + if star { + ctyp = "(" + typ + ")" + } + + g.P("func (m *", ms.sym, ") ", get.name, "() []", typ, " {") + g.In() + g.P("o := ", val) + g.P("if o == nil {") + g.In() + g.P("return nil") + g.Out() + g.P("}") + g.P("s := make([]", typ, ", len(o))") + g.P("for i, x := range o {") + g.In() + g.P("s[i] = ", ctyp, "(x)") + g.Out() + g.P("}") + g.P("return s") + g.Out() + g.P("}") + continue + } + if isMap { + // Split map[keyTyp]valTyp. + bra, ket := strings.Index(typ, "["), strings.Index(typ, "]") + keyTyp, valTyp := typ[bra+1:ket], typ[ket+1:] + // Drop any package qualifier. + // Only the value type may be foreign. + star := valTyp[0] == '*' + valTyp = valTyp[strings.Index(valTyp, ".")+1:] + if star { + valTyp = "*" + valTyp + } + + typ := "map[" + keyTyp + "]" + valTyp + g.P("func (m *", ms.sym, ") ", get.name, "() ", typ, " {") + g.P("o := ", val) + g.P("if o == nil { return nil }") + g.P("s := make(", typ, ", len(o))") + g.P("for k, v := range o {") + g.P("s[k] = (", valTyp, ")(v)") + g.P("}") + g.P("return s") + g.P("}") + continue + } + // Convert imported type into the forwarding type. + val = "(" + typ + ")(" + val + ")" + } + + g.P("func (m *", ms.sym, ") ", get.name, "() ", typ, " { return ", val, " }") + } + +} + +type enumSymbol struct { + name string + proto3 bool // Whether this came from a proto3 file. +} + +func (es enumSymbol) GenerateAlias(g *Generator, pkg string) { + s := es.name + g.P("type ", s, " ", pkg, ".", s) + g.P("var ", s, "_name = ", pkg, ".", s, "_name") + g.P("var ", s, "_value = ", pkg, ".", s, "_value") + g.P("func (x ", s, ") String() string { return (", pkg, ".", s, ")(x).String() }") + if !es.proto3 { + g.P("func (x ", s, ") Enum() *", s, "{ return (*", s, ")((", pkg, ".", s, ")(x).Enum()) }") + g.P("func (x *", s, ") UnmarshalJSON(data []byte) error { return (*", pkg, ".", s, ")(x).UnmarshalJSON(data) }") + } +} + +type constOrVarSymbol struct { + sym string + typ string // either "const" or "var" + cast string // if non-empty, a type cast is required (used for enums) +} + +func (cs constOrVarSymbol) GenerateAlias(g *Generator, pkg string) { + v := pkg + "." + cs.sym + if cs.cast != "" { + v = cs.cast + "(" + v + ")" + } + g.P(cs.typ, " ", cs.sym, " = ", v) +} + +// Object is an interface abstracting the abilities shared by enums, messages, extensions and imported objects. +type Object interface { + PackageName() string // The name we use in our output (a_b_c), possibly renamed for uniqueness. + TypeName() []string + File() *descriptor.FileDescriptorProto +} + +// Each package name we generate must be unique. The package we're generating +// gets its own name but every other package must have a unique name that does +// not conflict in the code we generate. These names are chosen globally (although +// they don't have to be, it simplifies things to do them globally). +func uniquePackageOf(fd *descriptor.FileDescriptorProto) string { + s, ok := uniquePackageName[fd] + if !ok { + log.Fatal("internal error: no package name defined for " + fd.GetName()) + } + return s +} + +// Generator is the type whose methods generate the output, stored in the associated response structure. +type Generator struct { + *bytes.Buffer + + Request *plugin.CodeGeneratorRequest // The input. + Response *plugin.CodeGeneratorResponse // The output. + + Param map[string]string // Command-line parameters. + PackageImportPath string // Go import path of the package we're generating code for + ImportPrefix string // String to prefix to imported package file names. + ImportMap map[string]string // Mapping from import name to generated name + + Pkg map[string]string // The names under which we import support packages + + packageName string // What we're calling ourselves. + allFiles []*FileDescriptor // All files in the tree + genFiles []*FileDescriptor // Those files we will generate output for. + file *FileDescriptor // The file we are compiling now. + usedPackages map[string]bool // Names of packages used in current file. + typeNameToObject map[string]Object // Key is a fully-qualified name in input syntax. + init []string // Lines to emit in the init function. + customImports []string + indent string + writtenImports map[string]bool // For de-duplicating written imports +} + +// New creates a new generator and allocates the request and response protobufs. +func New() *Generator { + g := new(Generator) + g.Buffer = new(bytes.Buffer) + g.Request = new(plugin.CodeGeneratorRequest) + g.Response = new(plugin.CodeGeneratorResponse) + g.writtenImports = make(map[string]bool) + uniquePackageName = make(map[*descriptor.FileDescriptorProto]string) + pkgNamesInUse = make(map[string][]*FileDescriptor) + return g +} + +// Error reports a problem, including an error, and exits the program. +func (g *Generator) Error(err error, msgs ...string) { + s := strings.Join(msgs, " ") + ":" + err.Error() + log.Print("protoc-gen-gogo: error:", s) + os.Exit(1) +} + +// Fail reports a problem and exits the program. +func (g *Generator) Fail(msgs ...string) { + s := strings.Join(msgs, " ") + log.Print("protoc-gen-gogo: error:", s) + os.Exit(1) +} + +// CommandLineParameters breaks the comma-separated list of key=value pairs +// in the parameter (a member of the request protobuf) into a key/value map. +// It then sets file name mappings defined by those entries. +func (g *Generator) CommandLineParameters(parameter string) { + g.Param = make(map[string]string) + for _, p := range strings.Split(parameter, ",") { + if i := strings.Index(p, "="); i < 0 { + g.Param[p] = "" + } else { + g.Param[p[0:i]] = p[i+1:] + } + } + + g.ImportMap = make(map[string]string) + pluginList := "none" // Default list of plugin names to enable (empty means all). + for k, v := range g.Param { + switch k { + case "import_prefix": + g.ImportPrefix = v + case "import_path": + g.PackageImportPath = v + case "plugins": + pluginList = v + default: + if len(k) > 0 && k[0] == 'M' { + g.ImportMap[k[1:]] = v + } + } + } + + if pluginList == "" { + return + } + if pluginList == "none" { + pluginList = "" + } + gogoPluginNames := []string{"unmarshal", "unsafeunmarshaler", "union", "stringer", "size", "populate", "marshalto", "unsafemarshaler", "gostring", "face", "equal", "enumstringer", "embedcheck", "description", "defaultcheck", "oneofcheck"} + pluginList = strings.Join(append(gogoPluginNames, pluginList), "+") + if pluginList != "" { + // Amend the set of plugins. + enabled := make(map[string]bool) + for _, name := range strings.Split(pluginList, "+") { + enabled[name] = true + } + var nplugins pluginSlice + for _, p := range plugins { + if enabled[p.Name()] { + nplugins = append(nplugins, p) + } + } + sort.Sort(nplugins) + plugins = nplugins + } +} + +// DefaultPackageName returns the package name printed for the object. +// If its file is in a different package, it returns the package name we're using for this file, plus ".". +// Otherwise it returns the empty string. +func (g *Generator) DefaultPackageName(obj Object) string { + pkg := obj.PackageName() + if pkg == g.packageName { + return "" + } + return pkg + "." +} + +// For each input file, the unique package name to use, underscored. +var uniquePackageName = make(map[*descriptor.FileDescriptorProto]string) + +// Package names already registered. Key is the name from the .proto file; +// value is the name that appears in the generated code. +var pkgNamesInUse = make(map[string][]*FileDescriptor) + +// Create and remember a guaranteed unique package name for this file descriptor. +// Pkg is the candidate name. If f is nil, it's a builtin package like "proto" and +// has no file descriptor. +func RegisterUniquePackageName(pkg string, f *FileDescriptor) string { + // Convert dots to underscores before finding a unique alias. + pkg = strings.Map(badToUnderscore, pkg) + + var i = -1 + var ptr *FileDescriptor = nil + for i, ptr = range pkgNamesInUse[pkg] { + if ptr == f { + if i == 0 { + return pkg + } + return pkg + strconv.Itoa(i) + } + } + + pkgNamesInUse[pkg] = append(pkgNamesInUse[pkg], f) + i += 1 + + if i > 0 { + pkg = pkg + strconv.Itoa(i) + } + + if f != nil { + uniquePackageName[f.FileDescriptorProto] = pkg + } + return pkg +} + +var isGoKeyword = map[string]bool{ + "break": true, + "case": true, + "chan": true, + "const": true, + "continue": true, + "default": true, + "else": true, + "defer": true, + "fallthrough": true, + "for": true, + "func": true, + "go": true, + "goto": true, + "if": true, + "import": true, + "interface": true, + "map": true, + "package": true, + "range": true, + "return": true, + "select": true, + "struct": true, + "switch": true, + "type": true, + "var": true, +} + +// defaultGoPackage returns the package name to use, +// derived from the import path of the package we're building code for. +func (g *Generator) defaultGoPackage() string { + p := g.PackageImportPath + if i := strings.LastIndex(p, "/"); i >= 0 { + p = p[i+1:] + } + if p == "" { + return "" + } + + p = strings.Map(badToUnderscore, p) + // Identifier must not be keyword: insert _. + if isGoKeyword[p] { + p = "_" + p + } + // Identifier must not begin with digit: insert _. + if r, _ := utf8.DecodeRuneInString(p); unicode.IsDigit(r) { + p = "_" + p + } + return p +} + +// SetPackageNames sets the package name for this run. +// The package name must agree across all files being generated. +// It also defines unique package names for all imported files. +func (g *Generator) SetPackageNames() { + // Register the name for this package. It will be the first name + // registered so is guaranteed to be unmodified. + pkg, explicit := g.genFiles[0].goPackageName() + + // Check all files for an explicit go_package option. + for _, f := range g.genFiles { + thisPkg, thisExplicit := f.goPackageName() + if thisExplicit { + if !explicit { + // Let this file's go_package option serve for all input files. + pkg, explicit = thisPkg, true + } else if thisPkg != pkg { + g.Fail("inconsistent package names:", thisPkg, pkg) + } + } + } + + // If we don't have an explicit go_package option but we have an + // import path, use that. + if !explicit { + p := g.defaultGoPackage() + if p != "" { + pkg, explicit = p, true + } + } + + // If there was no go_package and no import path to use, + // double-check that all the inputs have the same implicit + // Go package name. + if !explicit { + for _, f := range g.genFiles { + thisPkg, _ := f.goPackageName() + if thisPkg != pkg { + g.Fail("inconsistent package names:", thisPkg, pkg) + } + } + } + + g.packageName = RegisterUniquePackageName(pkg, g.genFiles[0]) + + // Register the support package names. They might collide with the + // name of a package we import. + g.Pkg = map[string]string{ + "fmt": RegisterUniquePackageName("fmt", nil), + "math": RegisterUniquePackageName("math", nil), + "proto": RegisterUniquePackageName("proto", nil), + } + +AllFiles: + for _, f := range g.allFiles { + for _, genf := range g.genFiles { + if f == genf { + // In this package already. + uniquePackageName[f.FileDescriptorProto] = g.packageName + continue AllFiles + } + } + // The file is a dependency, so we want to ignore its go_package option + // because that is only relevant for its specific generated output. + pkg := f.GetPackage() + if pkg == "" { + pkg = baseName(*f.Name) + } + RegisterUniquePackageName(pkg, f) + } +} + +// WrapTypes walks the incoming data, wrapping DescriptorProtos, EnumDescriptorProtos +// and FileDescriptorProtos into file-referenced objects within the Generator. +// It also creates the list of files to generate and so should be called before GenerateAllFiles. +func (g *Generator) WrapTypes() { + g.allFiles = make([]*FileDescriptor, len(g.Request.ProtoFile)) + for i, f := range g.Request.ProtoFile { + // We must wrap the descriptors before we wrap the enums + descs := wrapDescriptors(f) + g.buildNestedDescriptors(descs) + enums := wrapEnumDescriptors(f, descs) + g.buildNestedEnums(descs, enums) + exts := wrapExtensions(f) + imps := wrapImported(f, g) + fd := &FileDescriptor{ + FileDescriptorProto: f, + desc: descs, + enum: enums, + ext: exts, + imp: imps, + exported: make(map[Object][]symbol), + proto3: fileIsProto3(f), + } + extractComments(fd) + g.allFiles[i] = fd + } + + g.genFiles = make([]*FileDescriptor, len(g.Request.FileToGenerate)) +FindFiles: + for i, fileName := range g.Request.FileToGenerate { + // Search the list. This algorithm is n^2 but n is tiny. + for _, file := range g.allFiles { + if fileName == file.GetName() { + g.genFiles[i] = file + file.index = i + continue FindFiles + } + } + g.Fail("could not find file named", fileName) + } + g.Response.File = make([]*plugin.CodeGeneratorResponse_File, len(g.genFiles)) +} + +// Scan the descriptors in this file. For each one, build the slice of nested descriptors +func (g *Generator) buildNestedDescriptors(descs []*Descriptor) { + for _, desc := range descs { + if len(desc.NestedType) != 0 { + for _, nest := range descs { + if nest.parent == desc { + desc.nested = append(desc.nested, nest) + } + } + if len(desc.nested) != len(desc.NestedType) { + g.Fail("internal error: nesting failure for", desc.GetName()) + } + } + } +} + +func (g *Generator) buildNestedEnums(descs []*Descriptor, enums []*EnumDescriptor) { + for _, desc := range descs { + if len(desc.EnumType) != 0 { + for _, enum := range enums { + if enum.parent == desc { + desc.enums = append(desc.enums, enum) + } + } + if len(desc.enums) != len(desc.EnumType) { + g.Fail("internal error: enum nesting failure for", desc.GetName()) + } + } + } +} + +// Construct the Descriptor +func newDescriptor(desc *descriptor.DescriptorProto, parent *Descriptor, file *descriptor.FileDescriptorProto, index int) *Descriptor { + d := &Descriptor{ + common: common{file}, + DescriptorProto: desc, + parent: parent, + index: index, + } + if parent == nil { + d.path = fmt.Sprintf("%d,%d", messagePath, index) + } else { + d.path = fmt.Sprintf("%s,%d,%d", parent.path, messageMessagePath, index) + } + + // The only way to distinguish a group from a message is whether + // the containing message has a TYPE_GROUP field that matches. + if parent != nil { + parts := d.TypeName() + if file.Package != nil { + parts = append([]string{*file.Package}, parts...) + } + exp := "." + strings.Join(parts, ".") + for _, field := range parent.Field { + if field.GetType() == descriptor.FieldDescriptorProto_TYPE_GROUP && field.GetTypeName() == exp { + d.group = true + break + } + } + } + + d.ext = make([]*ExtensionDescriptor, len(desc.Extension)) + for i, field := range desc.Extension { + d.ext[i] = &ExtensionDescriptor{common{file}, field, d} + } + + return d +} + +// Return a slice of all the Descriptors defined within this file +func wrapDescriptors(file *descriptor.FileDescriptorProto) []*Descriptor { + sl := make([]*Descriptor, 0, len(file.MessageType)+10) + for i, desc := range file.MessageType { + sl = wrapThisDescriptor(sl, desc, nil, file, i) + } + return sl +} + +// Wrap this Descriptor, recursively +func wrapThisDescriptor(sl []*Descriptor, desc *descriptor.DescriptorProto, parent *Descriptor, file *descriptor.FileDescriptorProto, index int) []*Descriptor { + sl = append(sl, newDescriptor(desc, parent, file, index)) + me := sl[len(sl)-1] + for i, nested := range desc.NestedType { + sl = wrapThisDescriptor(sl, nested, me, file, i) + } + return sl +} + +// Construct the EnumDescriptor +func newEnumDescriptor(desc *descriptor.EnumDescriptorProto, parent *Descriptor, file *descriptor.FileDescriptorProto, index int) *EnumDescriptor { + ed := &EnumDescriptor{ + common: common{file}, + EnumDescriptorProto: desc, + parent: parent, + index: index, + } + if parent == nil { + ed.path = fmt.Sprintf("%d,%d", enumPath, index) + } else { + ed.path = fmt.Sprintf("%s,%d,%d", parent.path, messageEnumPath, index) + } + return ed +} + +// Return a slice of all the EnumDescriptors defined within this file +func wrapEnumDescriptors(file *descriptor.FileDescriptorProto, descs []*Descriptor) []*EnumDescriptor { + sl := make([]*EnumDescriptor, 0, len(file.EnumType)+10) + // Top-level enums. + for i, enum := range file.EnumType { + sl = append(sl, newEnumDescriptor(enum, nil, file, i)) + } + // Enums within messages. Enums within embedded messages appear in the outer-most message. + for _, nested := range descs { + for i, enum := range nested.EnumType { + sl = append(sl, newEnumDescriptor(enum, nested, file, i)) + } + } + return sl +} + +// Return a slice of all the top-level ExtensionDescriptors defined within this file. +func wrapExtensions(file *descriptor.FileDescriptorProto) []*ExtensionDescriptor { + sl := make([]*ExtensionDescriptor, len(file.Extension)) + for i, field := range file.Extension { + sl[i] = &ExtensionDescriptor{common{file}, field, nil} + } + return sl +} + +// Return a slice of all the types that are publicly imported into this file. +func wrapImported(file *descriptor.FileDescriptorProto, g *Generator) (sl []*ImportedDescriptor) { + for _, index := range file.PublicDependency { + df := g.fileByName(file.Dependency[index]) + for _, d := range df.desc { + if d.GetOptions().GetMapEntry() { + continue + } + sl = append(sl, &ImportedDescriptor{common{file}, d}) + } + for _, e := range df.enum { + sl = append(sl, &ImportedDescriptor{common{file}, e}) + } + for _, ext := range df.ext { + sl = append(sl, &ImportedDescriptor{common{file}, ext}) + } + } + return +} + +func extractComments(file *FileDescriptor) { + file.comments = make(map[string]*descriptor.SourceCodeInfo_Location) + for _, loc := range file.GetSourceCodeInfo().GetLocation() { + if loc.LeadingComments == nil { + continue + } + var p []string + for _, n := range loc.Path { + p = append(p, strconv.Itoa(int(n))) + } + file.comments[strings.Join(p, ",")] = loc + } +} + +// BuildTypeNameMap builds the map from fully qualified type names to objects. +// The key names for the map come from the input data, which puts a period at the beginning. +// It should be called after SetPackageNames and before GenerateAllFiles. +func (g *Generator) BuildTypeNameMap() { + g.typeNameToObject = make(map[string]Object) + for _, f := range g.allFiles { + // The names in this loop are defined by the proto world, not us, so the + // package name may be empty. If so, the dotted package name of X will + // be ".X"; otherwise it will be ".pkg.X". + dottedPkg := "." + f.GetPackage() + if dottedPkg != "." { + dottedPkg += "." + } + for _, enum := range f.enum { + name := dottedPkg + dottedSlice(enum.TypeName()) + g.typeNameToObject[name] = enum + } + for _, desc := range f.desc { + name := dottedPkg + dottedSlice(desc.TypeName()) + g.typeNameToObject[name] = desc + } + } +} + +// ObjectNamed, given a fully-qualified input type name as it appears in the input data, +// returns the descriptor for the message or enum with that name. +func (g *Generator) ObjectNamed(typeName string) Object { + o, ok := g.typeNameToObject[typeName] + if !ok { + g.Fail("can't find object with type", typeName) + } + + // If the file of this object isn't a direct dependency of the current file, + // or in the current file, then this object has been publicly imported into + // a dependency of the current file. + // We should return the ImportedDescriptor object for it instead. + direct := *o.File().Name == *g.file.Name + if !direct { + for _, dep := range g.file.Dependency { + if *g.fileByName(dep).Name == *o.File().Name { + direct = true + break + } + } + } + if !direct { + found := false + Loop: + for _, dep := range g.file.Dependency { + df := g.fileByName(*g.fileByName(dep).Name) + for _, td := range df.imp { + if td.o == o { + // Found it! + o = td + found = true + break Loop + } + } + } + if !found { + log.Printf("protoc-gen-gogo: WARNING: failed finding publicly imported dependency for %v, used in %v", typeName, *g.file.Name) + } + } + + return o +} + +// P prints the arguments to the generated output. It handles strings and int32s, plus +// handling indirections because they may be *string, etc. +func (g *Generator) P(str ...interface{}) { + g.WriteString(g.indent) + for _, v := range str { + switch s := v.(type) { + case string: + g.WriteString(s) + case *string: + g.WriteString(*s) + case bool: + g.WriteString(fmt.Sprintf("%t", s)) + case *bool: + g.WriteString(fmt.Sprintf("%t", *s)) + case int: + g.WriteString(fmt.Sprintf("%d", s)) + case *int32: + g.WriteString(fmt.Sprintf("%d", *s)) + case *int64: + g.WriteString(fmt.Sprintf("%d", *s)) + case float64: + g.WriteString(fmt.Sprintf("%g", s)) + case *float64: + g.WriteString(fmt.Sprintf("%g", *s)) + default: + g.Fail(fmt.Sprintf("unknown type in printer: %T", v)) + } + } + g.WriteByte('\n') +} + +// addInitf stores the given statement to be printed inside the file's init function. +// The statement is given as a format specifier and arguments. +func (g *Generator) addInitf(stmt string, a ...interface{}) { + g.init = append(g.init, fmt.Sprintf(stmt, a...)) +} + +func (g *Generator) PrintImport(alias, pkg string) { + statement := "import " + alias + " " + strconv.Quote(pkg) + if g.writtenImports[statement] { + return + } + g.P(statement) + g.writtenImports[statement] = true +} + +// In Indents the output one tab stop. +func (g *Generator) In() { g.indent += "\t" } + +// Out unindents the output one tab stop. +func (g *Generator) Out() { + if len(g.indent) > 0 { + g.indent = g.indent[1:] + } +} + +// GenerateAllFiles generates the output for all the files we're outputting. +func (g *Generator) GenerateAllFiles() { + // Initialize the plugins + for _, p := range plugins { + p.Init(g) + } + // Generate the output. The generator runs for every file, even the files + // that we don't generate output for, so that we can collate the full list + // of exported symbols to support public imports. + genFileMap := make(map[*FileDescriptor]bool, len(g.genFiles)) + for _, file := range g.genFiles { + genFileMap[file] = true + } + i := 0 + for _, file := range g.allFiles { + g.Reset() + g.generate(file) + if _, ok := genFileMap[file]; !ok { + continue + } + g.Response.File[i] = new(plugin.CodeGeneratorResponse_File) + g.Response.File[i].Name = proto.String(goFileName(*file.Name)) + g.Response.File[i].Content = proto.String(g.String()) + i++ + } +} + +// Run all the plugins associated with the file. +func (g *Generator) runPlugins(file *FileDescriptor) { + for _, p := range plugins { + p.Generate(file) + } +} + +// FileOf return the FileDescriptor for this FileDescriptorProto. +func (g *Generator) FileOf(fd *descriptor.FileDescriptorProto) *FileDescriptor { + for _, file := range g.allFiles { + if file.FileDescriptorProto == fd { + return file + } + } + g.Fail("could not find file in table:", fd.GetName()) + return nil +} + +// Fill the response protocol buffer with the generated output for all the files we're +// supposed to generate. +func (g *Generator) generate(file *FileDescriptor) { + g.customImports = make([]string, 0) + g.file = g.FileOf(file.FileDescriptorProto) + g.usedPackages = make(map[string]bool) + // Reset on each file + g.writtenImports = make(map[string]bool) + + for _, td := range g.file.imp { + g.generateImported(td) + } + for _, enum := range g.file.enum { + g.generateEnum(enum) + } + for _, desc := range g.file.desc { + // Don't generate virtual messages for maps. + if desc.GetOptions().GetMapEntry() { + continue + } + g.generateMessage(desc) + } + for _, ext := range g.file.ext { + g.generateExtension(ext) + } + g.generateInitFunction() + + // Run the plugins before the imports so we know which imports are necessary. + g.runPlugins(file) + + // Generate header and imports last, though they appear first in the output. + rem := g.Buffer + g.Buffer = new(bytes.Buffer) + g.generateHeader() + g.generateImports() + g.Write(rem.Bytes()) + + // Reformat generated code. + fset := token.NewFileSet() + raw := g.Bytes() + ast, err := parser.ParseFile(fset, "", g, parser.ParseComments) + if err != nil { + // Print out the bad code with line numbers. + // This should never happen in practice, but it can while changing generated code, + // so consider this a debugging aid. + var src bytes.Buffer + s := bufio.NewScanner(bytes.NewReader(raw)) + for line := 1; s.Scan(); line++ { + fmt.Fprintf(&src, "%5d\t%s\n", line, s.Bytes()) + } + if serr := s.Err(); serr != nil { + g.Fail("bad Go source code was generated:", err.Error(), "\n"+string(raw)) + } else { + g.Fail("bad Go source code was generated:", err.Error(), "\n"+src.String()) + } + } + g.Reset() + err = (&printer.Config{Mode: printer.TabIndent | printer.UseSpaces, Tabwidth: 8}).Fprint(g, fset, ast) + if err != nil { + g.Fail("generated Go source code could not be reformatted:", err.Error()) + } +} + +// Generate the header, including package definition +func (g *Generator) generateHeader() { + g.P("// Code generated by protoc-gen-gogo.") + g.P("// source: ", *g.file.Name) + g.P("// DO NOT EDIT!") + g.P() + + name := g.file.PackageName() + + if g.file.index == 0 { + // Generate package docs for the first file in the package. + g.P("/*") + g.P("Package ", name, " is a generated protocol buffer package.") + g.P() + if loc, ok := g.file.comments[strconv.Itoa(packagePath)]; ok { + // not using g.PrintComments because this is a /* */ comment block. + text := strings.TrimSuffix(loc.GetLeadingComments(), "\n") + for _, line := range strings.Split(text, "\n") { + line = strings.TrimPrefix(line, " ") + // ensure we don't escape from the block comment + line = strings.Replace(line, "*/", "* /", -1) + g.P(line) + } + g.P() + } + var topMsgs []string + g.P("It is generated from these files:") + for _, f := range g.genFiles { + g.P("\t", f.Name) + for _, msg := range f.desc { + if msg.parent != nil { + continue + } + topMsgs = append(topMsgs, CamelCaseSlice(msg.TypeName())) + } + } + g.P() + g.P("It has these top-level messages:") + for _, msg := range topMsgs { + g.P("\t", msg) + } + g.P("*/") + } + + g.P("package ", name) + g.P() +} + +// PrintComments prints any comments from the source .proto file. +// The path is a comma-separated list of integers. +// It returns an indication of whether any comments were printed. +// See descriptor.proto for its format. +func (g *Generator) PrintComments(path string) bool { + if loc, ok := g.file.comments[path]; ok { + text := strings.TrimSuffix(loc.GetLeadingComments(), "\n") + for _, line := range strings.Split(text, "\n") { + g.P("// ", strings.TrimPrefix(line, " ")) + } + return true + } + return false +} + +// Comments returns any comments from the source .proto file and empty string if comments not found. +// The path is a comma-separated list of intergers. +// See descriptor.proto for its format. +func (g *Generator) Comments(path string) string { + loc, ok := g.file.comments[path] + if !ok { + return "" + } + text := strings.TrimSuffix(loc.GetLeadingComments(), "\n") + return text +} + +func (g *Generator) fileByName(filename string) *FileDescriptor { + for _, fd := range g.allFiles { + if fd.GetName() == filename { + return fd + } + } + return nil +} + +// weak returns whether the ith import of the current file is a weak import. +func (g *Generator) weak(i int32) bool { + for _, j := range g.file.WeakDependency { + if j == i { + return true + } + } + return false +} + +// Generate the imports +func (g *Generator) generateImports() { + // We almost always need a proto import. Rather than computing when we + // do, which is tricky when there's a plugin, just import it and + // reference it later. The same argument applies to the fmt and math packages. + if gogoproto.ImportsGoGoProto(g.file.FileDescriptorProto) { + g.PrintImport(g.Pkg["proto"], g.ImportPrefix+"github.com/gogo/protobuf/proto") + } else { + g.PrintImport(g.Pkg["proto"], g.ImportPrefix+"github.com/golang/protobuf/proto") + } + g.PrintImport(g.Pkg["fmt"], "fmt") + g.PrintImport(g.Pkg["math"], "math") + + for i, s := range g.file.Dependency { + fd := g.fileByName(s) + // Do not import our own package. + if fd.PackageName() == g.packageName { + continue + } + filename := goFileName(s) + // By default, import path is the dirname of the Go filename. + importPath := path.Dir(filename) + if substitution, ok := g.ImportMap[s]; ok { + importPath = substitution + } + importPath = g.ImportPrefix + importPath + // Skip weak imports. + if g.weak(int32(i)) { + g.P("// skipping weak import ", fd.PackageName(), " ", strconv.Quote(importPath)) + continue + } + if _, ok := g.usedPackages[fd.PackageName()]; ok { + g.PrintImport(fd.PackageName(), importPath) + } else { + // TODO: Re-enable this when we are more feature-complete. + // For instance, some protos use foreign field extensions, which we don't support. + // Until then, this is just annoying spam. + //log.Printf("protoc-gen-go: discarding unused import from %v: %v", *g.file.Name, s) + g.P("// discarding unused import ", fd.PackageName(), " ", strconv.Quote(importPath)) + } + } + g.P() + for _, s := range g.customImports { + s1 := strings.Map(badToUnderscore, s) + g.PrintImport(s1, s) + } + g.P() + // TODO: may need to worry about uniqueness across plugins + for _, p := range plugins { + p.GenerateImports(g.file) + g.P() + } + g.P("// Reference imports to suppress errors if they are not otherwise used.") + g.P("var _ = ", g.Pkg["proto"], ".Marshal") + g.P("var _ = ", g.Pkg["fmt"], ".Errorf") + g.P("var _ = ", g.Pkg["math"], ".Inf") + g.P() +} + +func (g *Generator) generateImported(id *ImportedDescriptor) { + // Don't generate public import symbols for files that we are generating + // code for, since those symbols will already be in this package. + // We can't simply avoid creating the ImportedDescriptor objects, + // because g.genFiles isn't populated at that stage. + tn := id.TypeName() + sn := tn[len(tn)-1] + df := g.FileOf(id.o.File()) + filename := *df.Name + for _, fd := range g.genFiles { + if *fd.Name == filename { + g.P("// Ignoring public import of ", sn, " from ", filename) + g.P() + return + } + } + g.P("// ", sn, " from public import ", filename) + g.usedPackages[df.PackageName()] = true + + for _, sym := range df.exported[id.o] { + sym.GenerateAlias(g, df.PackageName()) + } + + g.P() +} + +// Generate the enum definitions for this EnumDescriptor. +func (g *Generator) generateEnum(enum *EnumDescriptor) { + // The full type name + typeName := enum.TypeName() + // The full type name, CamelCased. + ccTypeName := CamelCaseSlice(typeName) + ccPrefix := enum.prefix() + + g.PrintComments(enum.path) + if !gogoproto.EnabledGoEnumPrefix(enum.file, enum.EnumDescriptorProto) { + ccPrefix = "" + } + g.P("type ", ccTypeName, " int32") + g.file.addExport(enum, enumSymbol{ccTypeName, enum.proto3()}) + g.P("const (") + g.In() + for i, e := range enum.Value { + g.PrintComments(fmt.Sprintf("%s,%d,%d", enum.path, enumValuePath, i)) + + name := ccPrefix + *e.Name + g.P(name, " ", ccTypeName, " = ", e.Number) + g.file.addExport(enum, constOrVarSymbol{name, "const", ccTypeName}) + } + g.Out() + g.P(")") + g.P("var ", ccTypeName, "_name = map[int32]string{") + g.In() + generated := make(map[int32]bool) // avoid duplicate values + for _, e := range enum.Value { + duplicate := "" + if _, present := generated[*e.Number]; present { + duplicate = "// Duplicate value: " + } + g.P(duplicate, e.Number, ": ", strconv.Quote(*e.Name), ",") + generated[*e.Number] = true + } + g.Out() + g.P("}") + g.P("var ", ccTypeName, "_value = map[string]int32{") + g.In() + for _, e := range enum.Value { + g.P(strconv.Quote(*e.Name), ": ", e.Number, ",") + } + g.Out() + g.P("}") + + if !enum.proto3() { + g.P("func (x ", ccTypeName, ") Enum() *", ccTypeName, " {") + g.In() + g.P("p := new(", ccTypeName, ")") + g.P("*p = x") + g.P("return p") + g.Out() + g.P("}") + } + + if gogoproto.IsGoEnumStringer(g.file.FileDescriptorProto, enum.EnumDescriptorProto) { + g.P("func (x ", ccTypeName, ") String() string {") + g.In() + g.P("return ", g.Pkg["proto"], ".EnumName(", ccTypeName, "_name, int32(x))") + g.Out() + g.P("}") + } + + if !enum.proto3() && !gogoproto.IsGoEnumStringer(g.file.FileDescriptorProto, enum.EnumDescriptorProto) { + g.P("func (x ", ccTypeName, ") MarshalJSON() ([]byte, error) {") + g.In() + g.P("return ", g.Pkg["proto"], ".MarshalJSONEnum(", ccTypeName, "_name, int32(x))") + g.Out() + g.P("}") + } + if !enum.proto3() { + g.P("func (x *", ccTypeName, ") UnmarshalJSON(data []byte) error {") + g.In() + g.P("value, err := ", g.Pkg["proto"], ".UnmarshalJSONEnum(", ccTypeName, `_value, data, "`, ccTypeName, `")`) + g.P("if err != nil {") + g.In() + g.P("return err") + g.Out() + g.P("}") + g.P("*x = ", ccTypeName, "(value)") + g.P("return nil") + g.Out() + g.P("}") + } + g.P() +} + +// The tag is a string like "varint,2,opt,name=fieldname,def=7" that +// identifies details of the field for the protocol buffer marshaling and unmarshaling +// code. The fields are: +// wire encoding +// protocol tag number +// opt,req,rep for optional, required, or repeated +// packed whether the encoding is "packed" (optional; repeated primitives only) +// name= the original declared name +// enum= the name of the enum type if it is an enum-typed field. +// proto3 if this field is in a proto3 message +// def= string representation of the default value, if any. +// The default value must be in a representation that can be used at run-time +// to generate the default value. Thus bools become 0 and 1, for instance. +func (g *Generator) goTag(message *Descriptor, field *descriptor.FieldDescriptorProto, wiretype string) string { + optrepreq := "" + switch { + case isOptional(field): + optrepreq = "opt" + case isRequired(field): + optrepreq = "req" + case isRepeated(field): + optrepreq = "rep" + } + var defaultValue string + if dv := field.DefaultValue; dv != nil { // set means an explicit default + defaultValue = *dv + // Some types need tweaking. + switch *field.Type { + case descriptor.FieldDescriptorProto_TYPE_BOOL: + if defaultValue == "true" { + defaultValue = "1" + } else { + defaultValue = "0" + } + case descriptor.FieldDescriptorProto_TYPE_STRING, + descriptor.FieldDescriptorProto_TYPE_BYTES: + // Nothing to do. Quoting is done for the whole tag. + case descriptor.FieldDescriptorProto_TYPE_ENUM: + // For enums we need to provide the integer constant. + obj := g.ObjectNamed(field.GetTypeName()) + if id, ok := obj.(*ImportedDescriptor); ok { + // It is an enum that was publicly imported. + // We need the underlying type. + obj = id.o + } + enum, ok := obj.(*EnumDescriptor) + if !ok { + log.Printf("obj is a %T", obj) + if id, ok := obj.(*ImportedDescriptor); ok { + log.Printf("id.o is a %T", id.o) + } + g.Fail("unknown enum type", CamelCaseSlice(obj.TypeName())) + } + defaultValue = enum.integerValueAsString(defaultValue) + } + defaultValue = ",def=" + defaultValue + } + enum := "" + if *field.Type == descriptor.FieldDescriptorProto_TYPE_ENUM { + // We avoid using obj.PackageName(), because we want to use the + // original (proto-world) package name. + obj := g.ObjectNamed(field.GetTypeName()) + if id, ok := obj.(*ImportedDescriptor); ok { + obj = id.o + } + enum = ",enum=" + if pkg := obj.File().GetPackage(); pkg != "" { + enum += pkg + "." + } + enum += CamelCaseSlice(obj.TypeName()) + } + packed := "" + if field.Options != nil && field.Options.GetPacked() { + packed = ",packed" + } + fieldName := field.GetName() + name := fieldName + if *field.Type == descriptor.FieldDescriptorProto_TYPE_GROUP { + // We must use the type name for groups instead of + // the field name to preserve capitalization. + // type_name in FieldDescriptorProto is fully-qualified, + // but we only want the local part. + name = *field.TypeName + if i := strings.LastIndex(name, "."); i >= 0 { + name = name[i+1:] + } + } + name = ",name=" + name + + embed := "" + if gogoproto.IsEmbed(field) { + embed = ",embedded=" + fieldName + } + + ctype := "" + if gogoproto.IsCustomType(field) { + ctype = ",customtype=" + gogoproto.GetCustomType(field) + } + + casttype := "" + if gogoproto.IsCastType(field) { + casttype = ",casttype=" + gogoproto.GetCastType(field) + } + + if message.proto3() { + // We only need the extra tag for []byte fields; + // no need to add noise for the others. + if *field.Type != descriptor.FieldDescriptorProto_TYPE_MESSAGE && + *field.Type != descriptor.FieldDescriptorProto_TYPE_GROUP && + !field.IsRepeated() { + name += ",proto3" + } + } + oneof := "" + if field.OneofIndex != nil { + oneof = ",oneof" + } + return strconv.Quote(fmt.Sprintf("%s,%d,%s%s%s%s%s%s%s%s%s", + wiretype, + field.GetNumber(), + optrepreq, + packed, + name, + enum, + oneof, + defaultValue, + embed, + ctype, + casttype)) +} + +func needsStar(field *descriptor.FieldDescriptorProto, proto3 bool, allowOneOf bool) bool { + if isRepeated(field) && + (*field.Type != descriptor.FieldDescriptorProto_TYPE_MESSAGE) && + (*field.Type != descriptor.FieldDescriptorProto_TYPE_GROUP) { + return false + } + if *field.Type == descriptor.FieldDescriptorProto_TYPE_BYTES && !gogoproto.IsCustomType(field) { + return false + } + if !gogoproto.IsNullable(field) { + return false + } + if field.OneofIndex != nil && allowOneOf && + (*field.Type != descriptor.FieldDescriptorProto_TYPE_MESSAGE) && + (*field.Type != descriptor.FieldDescriptorProto_TYPE_GROUP) { + return false + } + if proto3 && + (*field.Type != descriptor.FieldDescriptorProto_TYPE_MESSAGE) && + (*field.Type != descriptor.FieldDescriptorProto_TYPE_GROUP) { + return false + } + return true +} + +// TypeName is the printed name appropriate for an item. If the object is in the current file, +// TypeName drops the package name and underscores the rest. +// Otherwise the object is from another package; and the result is the underscored +// package name followed by the item name. +// The result always has an initial capital. +func (g *Generator) TypeName(obj Object) string { + return g.DefaultPackageName(obj) + CamelCaseSlice(obj.TypeName()) +} + +// TypeNameWithPackage is like TypeName, but always includes the package +// name even if the object is in our own package. +func (g *Generator) TypeNameWithPackage(obj Object) string { + return obj.PackageName() + CamelCaseSlice(obj.TypeName()) +} + +// GoType returns a string representing the type name, and the wire type +func (g *Generator) GoType(message *Descriptor, field *descriptor.FieldDescriptorProto) (typ string, wire string) { + // TODO: Options. + switch *field.Type { + case descriptor.FieldDescriptorProto_TYPE_DOUBLE: + typ, wire = "float64", "fixed64" + case descriptor.FieldDescriptorProto_TYPE_FLOAT: + typ, wire = "float32", "fixed32" + case descriptor.FieldDescriptorProto_TYPE_INT64: + typ, wire = "int64", "varint" + case descriptor.FieldDescriptorProto_TYPE_UINT64: + typ, wire = "uint64", "varint" + case descriptor.FieldDescriptorProto_TYPE_INT32: + typ, wire = "int32", "varint" + case descriptor.FieldDescriptorProto_TYPE_UINT32: + typ, wire = "uint32", "varint" + case descriptor.FieldDescriptorProto_TYPE_FIXED64: + typ, wire = "uint64", "fixed64" + case descriptor.FieldDescriptorProto_TYPE_FIXED32: + typ, wire = "uint32", "fixed32" + case descriptor.FieldDescriptorProto_TYPE_BOOL: + typ, wire = "bool", "varint" + case descriptor.FieldDescriptorProto_TYPE_STRING: + typ, wire = "string", "bytes" + case descriptor.FieldDescriptorProto_TYPE_GROUP: + desc := g.ObjectNamed(field.GetTypeName()) + typ, wire = g.TypeName(desc), "group" + case descriptor.FieldDescriptorProto_TYPE_MESSAGE: + desc := g.ObjectNamed(field.GetTypeName()) + typ, wire = g.TypeName(desc), "bytes" + case descriptor.FieldDescriptorProto_TYPE_BYTES: + typ, wire = "[]byte", "bytes" + case descriptor.FieldDescriptorProto_TYPE_ENUM: + desc := g.ObjectNamed(field.GetTypeName()) + typ, wire = g.TypeName(desc), "varint" + case descriptor.FieldDescriptorProto_TYPE_SFIXED32: + typ, wire = "int32", "fixed32" + case descriptor.FieldDescriptorProto_TYPE_SFIXED64: + typ, wire = "int64", "fixed64" + case descriptor.FieldDescriptorProto_TYPE_SINT32: + typ, wire = "int32", "zigzag32" + case descriptor.FieldDescriptorProto_TYPE_SINT64: + typ, wire = "int64", "zigzag64" + default: + g.Fail("unknown type for", field.GetName()) + } + if gogoproto.IsCustomType(field) && gogoproto.IsCastType(field) { + g.Fail(field.GetName() + " cannot be custom type and cast type") + } + if gogoproto.IsCustomType(field) { + var packageName string + var err error + packageName, typ, err = getCustomType(field) + if err != nil { + g.Fail(err.Error()) + } + if len(packageName) > 0 { + g.customImports = append(g.customImports, packageName) + } + } + if gogoproto.IsCastType(field) { + var packageName string + var err error + packageName, typ, err = getCastType(field) + if err != nil { + g.Fail(err.Error()) + } + if len(packageName) > 0 { + g.customImports = append(g.customImports, packageName) + } + } + if needsStar(field, g.file.proto3, message != nil && message.allowOneof()) { + typ = "*" + typ + } + if isRepeated(field) { + typ = "[]" + typ + } + return +} + +func (g *Generator) RecordTypeUse(t string) { + if obj, ok := g.typeNameToObject[t]; ok { + // Call ObjectNamed to get the true object to record the use. + obj = g.ObjectNamed(t) + g.usedPackages[obj.PackageName()] = true + } +} + +// Method names that may be generated. Fields with these names get an +// underscore appended. +var methodNames = [...]string{ + "Reset", + "String", + "ProtoMessage", + "Marshal", + "Unmarshal", + "ExtensionRangeArray", + "ExtensionMap", + "Descriptor", + "Size", + "MarshalTo", + "Equal", + "VerboseEqual", + "GoString", +} + +// Generate the type and default constant definitions for this Descriptor. +func (g *Generator) generateMessage(message *Descriptor) { + // The full type name + typeName := message.TypeName() + // The full type name, CamelCased. + ccTypeName := CamelCaseSlice(typeName) + + usedNames := make(map[string]bool) + for _, n := range methodNames { + usedNames[n] = true + } + fieldNames := make(map[*descriptor.FieldDescriptorProto]string) + fieldGetterNames := make(map[*descriptor.FieldDescriptorProto]string) + fieldTypes := make(map[*descriptor.FieldDescriptorProto]string) + mapFieldTypes := make(map[*descriptor.FieldDescriptorProto]string) + + oneofFieldName := make(map[int32]string) // indexed by oneof_index field of FieldDescriptorProto + oneofDisc := make(map[int32]string) // name of discriminator method + oneofTypeName := make(map[*descriptor.FieldDescriptorProto]string) // without star + oneofInsertPoints := make(map[int32]int) // oneof_index => offset of g.Buffer + + g.PrintComments(message.path) + g.P("type ", ccTypeName, " struct {") + g.In() + + // allocNames finds a conflict-free variation of the given strings, + // consistently mutating their suffixes. + // It returns the same number of strings. + allocNames := func(ns ...string) []string { + Loop: + for { + for _, n := range ns { + if usedNames[n] { + for i := range ns { + ns[i] += "_" + } + continue Loop + } + } + for _, n := range ns { + usedNames[n] = true + } + return ns + } + } + + for i, field := range message.Field { + // Allocate the getter and the field at the same time so name + // collisions create field/method consistent names. + // TODO: This allocation occurs based on the order of the fields + // in the proto file, meaning that a change in the field + // ordering can change generated Method/Field names. + base := CamelCase(*field.Name) + if gogoproto.IsCustomName(field) { + base = gogoproto.GetCustomName(field) + } + ns := allocNames(base, "Get"+base) + fieldName, fieldGetterName := ns[0], ns[1] + typename, wiretype := g.GoType(message, field) + jsonName := *field.Name + jsonTag := jsonName + ",omitempty" + repeatedNativeType := (!field.IsMessage() && !gogoproto.IsCustomType(field) && field.IsRepeated()) + if !gogoproto.IsNullable(field) && !repeatedNativeType { + jsonTag = jsonName + } + gogoJsonTag := gogoproto.GetJsonTag(field) + if gogoJsonTag != nil { + jsonTag = *gogoJsonTag + } + gogoMoreTags := gogoproto.GetMoreTags(field) + moreTags := "" + if gogoMoreTags != nil { + moreTags = " " + *gogoMoreTags + } + tag := fmt.Sprintf("protobuf:%s json:%q%s", g.goTag(message, field, wiretype), jsonTag, moreTags) + fieldNames[field] = fieldName + fieldGetterNames[field] = fieldGetterName + if *field.Type == descriptor.FieldDescriptorProto_TYPE_MESSAGE && gogoproto.IsEmbed(field) { + fieldName = "" + } + + oneof := field.OneofIndex != nil && message.allowOneof() + if oneof && oneofFieldName[*field.OneofIndex] == "" { + odp := message.OneofDecl[int(*field.OneofIndex)] + fname := allocNames(CamelCase(odp.GetName()))[0] + + // This is the first field of a oneof we haven't seen before. + // Generate the union field. + com := g.PrintComments(fmt.Sprintf("%s,%d,%d", message.path, messageOneofPath, *field.OneofIndex)) + if com { + g.P("//") + } + g.P("// Types that are valid to be assigned to ", fname, ":") + // Generate the rest of this comment later, + // when we've computed any disambiguation. + oneofInsertPoints[*field.OneofIndex] = g.Buffer.Len() + + dname := "is" + ccTypeName + "_" + fname + oneofFieldName[*field.OneofIndex] = fname + oneofDisc[*field.OneofIndex] = dname + tag := `protobuf_oneof:"` + odp.GetName() + `"` + g.P(fname, " ", dname, " `", tag, "`") + } + + if *field.Type == descriptor.FieldDescriptorProto_TYPE_MESSAGE { + desc := g.ObjectNamed(field.GetTypeName()) + if d, ok := desc.(*Descriptor); ok && d.GetOptions().GetMapEntry() { + // Figure out the Go types and tags for the key and value types. + keyField, valField := d.Field[0], d.Field[1] + keyType, keyWire := g.GoType(d, keyField) + valType, valWire := g.GoType(d, valField) + keyTag, valTag := g.goTag(d, keyField, keyWire), g.goTag(d, valField, valWire) + + // We don't use stars, except for message-typed values. + // Message and enum types are the only two possibly foreign types used in maps, + // so record their use. They are not permitted as map keys. + keyType = strings.TrimPrefix(keyType, "*") + switch *valField.Type { + case descriptor.FieldDescriptorProto_TYPE_ENUM: + valType = strings.TrimPrefix(valType, "*") + g.RecordTypeUse(valField.GetTypeName()) + case descriptor.FieldDescriptorProto_TYPE_MESSAGE: + g.RecordTypeUse(valField.GetTypeName()) + default: + valType = strings.TrimPrefix(valType, "*") + } + + typename = fmt.Sprintf("map[%s]%s", keyType, valType) + mapFieldTypes[field] = typename // record for the getter generation + + tag += fmt.Sprintf(" protobuf_key:%s protobuf_val:%s", keyTag, valTag) + } + } + + fieldTypes[field] = typename + + if oneof { + tname := ccTypeName + "_" + fieldName + // It is possible for this to collide with a message or enum + // nested in this message. Check for collisions. + for { + ok := true + for _, desc := range message.nested { + if CamelCaseSlice(desc.TypeName()) == tname { + ok = false + break + } + } + for _, enum := range message.enums { + if CamelCaseSlice(enum.TypeName()) == tname { + ok = false + break + } + } + if !ok { + tname += "_" + continue + } + break + } + + oneofTypeName[field] = tname + continue + } + + g.PrintComments(fmt.Sprintf("%s,%d,%d", message.path, messageFieldPath, i)) + g.P(fieldName, "\t", typename, "\t`", tag, "`") + g.RecordTypeUse(field.GetTypeName()) + } + if len(message.ExtensionRange) > 0 { + if gogoproto.HasExtensionsMap(g.file.FileDescriptorProto, message.DescriptorProto) { + g.P("XXX_extensions\t\tmap[int32]", g.Pkg["proto"], ".Extension `json:\"-\"`") + } else { + g.P("XXX_extensions\t\t[]byte `protobuf:\"bytes,0,opt\" json:\"-\"`") + } + } + if gogoproto.HasUnrecognized(g.file.FileDescriptorProto, message.DescriptorProto) && !message.proto3() { + g.P("XXX_unrecognized\t[]byte `json:\"-\"`") + } + g.Out() + g.P("}") + + // Update g.Buffer to list valid oneof types. + // We do this down here, after we've disambiguated the oneof type names. + // We go in reverse order of insertion point to avoid invalidating offsets. + for oi := int32(len(message.OneofDecl)); oi >= 0; oi-- { + ip := oneofInsertPoints[oi] + all := g.Buffer.Bytes() + rem := all[ip:] + g.Buffer = bytes.NewBuffer(all[:ip:ip]) // set cap so we don't scribble on rem + for _, field := range message.Field { + if field.OneofIndex == nil || *field.OneofIndex != oi { + continue + } + g.P("//\t*", oneofTypeName[field]) + } + g.Buffer.Write(rem) + } + + // Reset, String and ProtoMessage methods. + g.P("func (m *", ccTypeName, ") Reset() { *m = ", ccTypeName, "{} }") + if gogoproto.EnabledGoStringer(g.file.FileDescriptorProto, message.DescriptorProto) { + g.P("func (m *", ccTypeName, ") String() string { return ", g.Pkg["proto"], ".CompactTextString(m) }") + } + g.P("func (*", ccTypeName, ") ProtoMessage() {}") + + // Extension support methods + var hasExtensions, isMessageSet bool + if len(message.ExtensionRange) > 0 { + hasExtensions = true + // message_set_wire_format only makes sense when extensions are defined. + if opts := message.Options; opts != nil && opts.GetMessageSetWireFormat() { + isMessageSet = true + g.P() + g.P("func (m *", ccTypeName, ") Marshal() ([]byte, error) {") + g.In() + g.P("return ", g.Pkg["proto"], ".MarshalMessageSet(m.ExtensionMap())") + g.Out() + g.P("}") + g.P("func (m *", ccTypeName, ") Unmarshal(buf []byte) error {") + g.In() + g.P("return ", g.Pkg["proto"], ".UnmarshalMessageSet(buf, m.ExtensionMap())") + g.Out() + g.P("}") + g.P("func (m *", ccTypeName, ") MarshalJSON() ([]byte, error) {") + g.In() + g.P("return ", g.Pkg["proto"], ".MarshalMessageSetJSON(m.XXX_extensions)") + g.Out() + g.P("}") + g.P("func (m *", ccTypeName, ") UnmarshalJSON(buf []byte) error {") + g.In() + g.P("return ", g.Pkg["proto"], ".UnmarshalMessageSetJSON(buf, m.XXX_extensions)") + g.Out() + g.P("}") + g.P("// ensure ", ccTypeName, " satisfies proto.Marshaler and proto.Unmarshaler") + g.P("var _ ", g.Pkg["proto"], ".Marshaler = (*", ccTypeName, ")(nil)") + g.P("var _ ", g.Pkg["proto"], ".Unmarshaler = (*", ccTypeName, ")(nil)") + } + + g.P() + g.P("var extRange_", ccTypeName, " = []", g.Pkg["proto"], ".ExtensionRange{") + g.In() + for _, r := range message.ExtensionRange { + end := fmt.Sprint(*r.End - 1) // make range inclusive on both ends + g.P("{", r.Start, ", ", end, "},") + } + g.Out() + g.P("}") + g.P("func (*", ccTypeName, ") ExtensionRangeArray() []", g.Pkg["proto"], ".ExtensionRange {") + g.In() + g.P("return extRange_", ccTypeName) + g.Out() + g.P("}") + if gogoproto.HasExtensionsMap(g.file.FileDescriptorProto, message.DescriptorProto) { + g.P("func (m *", ccTypeName, ") ExtensionMap() map[int32]", g.Pkg["proto"], ".Extension {") + g.In() + g.P("if m.XXX_extensions == nil {") + g.In() + g.P("m.XXX_extensions = make(map[int32]", g.Pkg["proto"], ".Extension)") + g.Out() + g.P("}") + g.P("return m.XXX_extensions") + g.Out() + g.P("}") + } else { + g.P("func (m *", ccTypeName, ") GetExtensions() *[]byte {") + g.In() + g.P("if m.XXX_extensions == nil {") + g.In() + g.P("m.XXX_extensions = make([]byte, 0)") + g.Out() + g.P("}") + g.P("return &m.XXX_extensions") + g.Out() + g.P("}") + } + } + + // Default constants + defNames := make(map[*descriptor.FieldDescriptorProto]string) + for _, field := range message.Field { + def := field.GetDefaultValue() + if def == "" { + continue + } + if !gogoproto.IsNullable(field) { + g.Fail("illegal default value: ", field.GetName(), " in ", message.GetName(), " is not nullable and is thus not allowed to have a default value") + } + fieldname := "Default_" + ccTypeName + "_" + CamelCase(*field.Name) + defNames[field] = fieldname + typename, _ := g.GoType(message, field) + if typename[0] == '*' { + typename = typename[1:] + } + kind := "const " + switch { + case typename == "bool": + case typename == "string": + def = strconv.Quote(def) + case typename == "[]byte": + def = "[]byte(" + strconv.Quote(def) + ")" + kind = "var " + case def == "inf", def == "-inf", def == "nan": + // These names are known to, and defined by, the protocol language. + switch def { + case "inf": + def = "math.Inf(1)" + case "-inf": + def = "math.Inf(-1)" + case "nan": + def = "math.NaN()" + } + if *field.Type == descriptor.FieldDescriptorProto_TYPE_FLOAT { + def = "float32(" + def + ")" + } + kind = "var " + case *field.Type == descriptor.FieldDescriptorProto_TYPE_ENUM: + // Must be an enum. Need to construct the prefixed name. + obj := g.ObjectNamed(field.GetTypeName()) + var enum *EnumDescriptor + if id, ok := obj.(*ImportedDescriptor); ok { + // The enum type has been publicly imported. + enum, _ = id.o.(*EnumDescriptor) + } else { + enum, _ = obj.(*EnumDescriptor) + } + if enum == nil { + log.Printf("don't know how to generate constant for %s", fieldname) + continue + } + if gogoproto.EnabledGoEnumPrefix(enum.file, enum.EnumDescriptorProto) { + def = g.DefaultPackageName(obj) + enum.prefix() + def + } else { + def = g.DefaultPackageName(obj) + def + } + } + g.P(kind, fieldname, " ", typename, " = ", def) + g.file.addExport(message, constOrVarSymbol{fieldname, kind, ""}) + } + g.P() + + // Oneof per-field types, discriminants and getters. + if message.allowOneof() { + // Generate unexported named types for the discriminant interfaces. + // We shouldn't have to do this, but there was (~19 Aug 2015) a compiler/linker bug + // that was triggered by using anonymous interfaces here. + // TODO: Revisit this and consider reverting back to anonymous interfaces. + for oi := range message.OneofDecl { + dname := oneofDisc[int32(oi)] + g.P("type ", dname, " interface {") + g.In() + g.P(dname, "()") + if gogoproto.HasEqual(g.file.FileDescriptorProto, message.DescriptorProto) { + g.P(`Equal(interface{}) bool`) + } + if gogoproto.HasVerboseEqual(g.file.FileDescriptorProto, message.DescriptorProto) { + g.P(`VerboseEqual(interface{}) error`) + } + if gogoproto.IsMarshaler(g.file.FileDescriptorProto, message.DescriptorProto) || + gogoproto.IsUnsafeMarshaler(g.file.FileDescriptorProto, message.DescriptorProto) { + g.P(`MarshalTo([]byte) (int, error)`) + } + if gogoproto.IsSizer(g.file.FileDescriptorProto, message.DescriptorProto) { + g.P(`Size() int`) + } + g.Out() + g.P("}") + } + g.P() + for _, field := range message.Field { + if field.OneofIndex == nil { + continue + } + _, wiretype := g.GoType(message, field) + tag := "protobuf:" + g.goTag(message, field, wiretype) + g.P("type ", oneofTypeName[field], " struct{ ", fieldNames[field], " ", fieldTypes[field], " `", tag, "` }") + g.RecordTypeUse(field.GetTypeName()) + } + g.P() + for _, field := range message.Field { + if field.OneofIndex == nil { + continue + } + g.P("func (*", oneofTypeName[field], ") ", oneofDisc[*field.OneofIndex], "() {}") + } + g.P() + for oi := range message.OneofDecl { + fname := oneofFieldName[int32(oi)] + g.P("func (m *", ccTypeName, ") Get", fname, "() ", oneofDisc[int32(oi)], " {") + g.P("if m != nil { return m.", fname, " }") + g.P("return nil") + g.P("}") + } + g.P() + } + + // Field getters + var getters []getterSymbol + for _, field := range message.Field { + oneof := field.OneofIndex != nil && message.allowOneof() + if !oneof && !gogoproto.HasGoGetters(g.file.FileDescriptorProto, message.DescriptorProto) { + continue + } + if gogoproto.IsEmbed(field) || gogoproto.IsCustomType(field) { + continue + } + fname := fieldNames[field] + typename, _ := g.GoType(message, field) + if t, ok := mapFieldTypes[field]; ok { + typename = t + } + mname := fieldGetterNames[field] + star := "" + if (*field.Type != descriptor.FieldDescriptorProto_TYPE_MESSAGE) && + (*field.Type != descriptor.FieldDescriptorProto_TYPE_GROUP) && + needsStar(field, g.file.proto3, message != nil && message.allowOneof()) && typename[0] == '*' { + typename = typename[1:] + star = "*" + } + + // In proto3, only generate getters for message fields and oneof fields. + if message.proto3() && *field.Type != descriptor.FieldDescriptorProto_TYPE_MESSAGE && !oneof { + continue + } + + // Only export getter symbols for basic types, + // and for messages and enums in the same package. + // Groups are not exported. + // Foreign types can't be hoisted through a public import because + // the importer may not already be importing the defining .proto. + // As an example, imagine we have an import tree like this: + // A.proto -> B.proto -> C.proto + // If A publicly imports B, we need to generate the getters from B in A's output, + // but if one such getter returns something from C then we cannot do that + // because A is not importing C already. + var getter, genType bool + switch *field.Type { + case descriptor.FieldDescriptorProto_TYPE_GROUP: + getter = false + case descriptor.FieldDescriptorProto_TYPE_MESSAGE, descriptor.FieldDescriptorProto_TYPE_ENUM: + // Only export getter if its return type is in this package. + getter = g.ObjectNamed(field.GetTypeName()).PackageName() == message.PackageName() + genType = true + default: + getter = true + } + if getter { + getters = append(getters, getterSymbol{ + name: mname, + typ: typename, + typeName: field.GetTypeName(), + genType: genType, + }) + } + + g.P("func (m *", ccTypeName, ") "+mname+"() "+typename+" {") + g.In() + def, hasDef := defNames[field] + typeDefaultIsNil := false // whether this field type's default value is a literal nil unless specified + switch *field.Type { + case descriptor.FieldDescriptorProto_TYPE_BYTES: + typeDefaultIsNil = !hasDef + case descriptor.FieldDescriptorProto_TYPE_GROUP, descriptor.FieldDescriptorProto_TYPE_MESSAGE: + typeDefaultIsNil = gogoproto.IsNullable(field) + } + if isRepeated(field) { + typeDefaultIsNil = true + } + if typeDefaultIsNil && !oneof { + // A bytes field with no explicit default needs less generated code, + // as does a message or group field, or a repeated field. + g.P("if m != nil {") + g.In() + g.P("return m." + fname) + g.Out() + g.P("}") + g.P("return nil") + g.Out() + g.P("}") + g.P() + continue + } + if !gogoproto.IsNullable(field) { + g.P("if m != nil {") + g.In() + g.P("return m." + fname) + g.Out() + g.P("}") + } else if !oneof { + g.P("if m != nil && m." + fname + " != nil {") + g.In() + g.P("return " + star + "m." + fname) + g.Out() + g.P("}") + } else { + uname := oneofFieldName[*field.OneofIndex] + tname := oneofTypeName[field] + g.P("if x, ok := m.Get", uname, "().(*", tname, "); ok {") + g.P("return x.", fname) + g.P("}") + } + if hasDef { + if *field.Type != descriptor.FieldDescriptorProto_TYPE_BYTES { + g.P("return " + def) + } else { + // The default is a []byte var. + // Make a copy when returning it to be safe. + g.P("return append([]byte(nil), ", def, "...)") + } + } else { + switch *field.Type { + case descriptor.FieldDescriptorProto_TYPE_GROUP, + descriptor.FieldDescriptorProto_TYPE_MESSAGE: + if field.OneofIndex != nil { + g.P(`return nil`) + } else { + goTyp, _ := g.GoType(message, field) + goTypName := GoTypeToName(goTyp) + g.P("return ", goTypName, "{}") + } + case descriptor.FieldDescriptorProto_TYPE_BOOL: + g.P("return false") + case descriptor.FieldDescriptorProto_TYPE_STRING: + g.P(`return ""`) + case descriptor.FieldDescriptorProto_TYPE_BYTES: + // This is only possible for oneof fields. + g.P("return nil") + case descriptor.FieldDescriptorProto_TYPE_ENUM: + // The default default for an enum is the first value in the enum, + // not zero. + obj := g.ObjectNamed(field.GetTypeName()) + var enum *EnumDescriptor + if id, ok := obj.(*ImportedDescriptor); ok { + // The enum type has been publicly imported. + enum, _ = id.o.(*EnumDescriptor) + } else { + enum, _ = obj.(*EnumDescriptor) + } + if enum == nil { + log.Printf("don't know how to generate getter for %s", field.GetName()) + continue + } + if len(enum.Value) == 0 { + g.P("return 0 // empty enum") + } else { + first := enum.Value[0].GetName() + if gogoproto.EnabledGoEnumPrefix(enum.file, enum.EnumDescriptorProto) { + g.P("return ", g.DefaultPackageName(obj)+enum.prefix()+first) + } else { + g.P("return ", g.DefaultPackageName(obj)+first) + } + } + default: + g.P("return 0") + } + } + g.Out() + g.P("}") + g.P() + } + + if !message.group { + ms := &messageSymbol{sym: ccTypeName, hasExtensions: hasExtensions, isMessageSet: isMessageSet, getters: getters} + g.file.addExport(message, ms) + } + + // Oneof functions + if len(message.OneofDecl) > 0 && message.allowOneof() { + fieldWire := make(map[*descriptor.FieldDescriptorProto]string) + + // method + enc := "_" + ccTypeName + "_OneofMarshaler" + dec := "_" + ccTypeName + "_OneofUnmarshaler" + encSig := "(msg " + g.Pkg["proto"] + ".Message, b *" + g.Pkg["proto"] + ".Buffer) error" + decSig := "(msg " + g.Pkg["proto"] + ".Message, tag, wire int, b *" + g.Pkg["proto"] + ".Buffer) (bool, error)" + + g.P("// XXX_OneofFuncs is for the internal use of the proto package.") + g.P("func (*", ccTypeName, ") XXX_OneofFuncs() (func", encSig, ", func", decSig, ", []interface{}) {") + g.P("return ", enc, ", ", dec, ", []interface{}{") + for _, field := range message.Field { + if field.OneofIndex == nil { + continue + } + g.P("(*", oneofTypeName[field], ")(nil),") + } + g.P("}") + g.P("}") + g.P() + + // marshaler + g.P("func ", enc, encSig, " {") + g.P("m := msg.(*", ccTypeName, ")") + for oi, odp := range message.OneofDecl { + g.P("// ", odp.GetName()) + fname := oneofFieldName[int32(oi)] + g.P("switch x := m.", fname, ".(type) {") + for _, field := range message.Field { + if field.OneofIndex == nil || int(*field.OneofIndex) != oi { + continue + } + g.P("case *", oneofTypeName[field], ":") + var wire, pre, post string + val := "x." + fieldNames[field] // overridden for TYPE_BOOL + canFail := false // only TYPE_MESSAGE and TYPE_GROUP can fail + switch *field.Type { + case descriptor.FieldDescriptorProto_TYPE_DOUBLE: + wire = "WireFixed64" + pre = "b.EncodeFixed64(" + g.Pkg["math"] + ".Float64bits(" + post = "))" + case descriptor.FieldDescriptorProto_TYPE_FLOAT: + wire = "WireFixed32" + pre = "b.EncodeFixed32(uint64(" + g.Pkg["math"] + ".Float32bits(" + post = ")))" + case descriptor.FieldDescriptorProto_TYPE_INT64, + descriptor.FieldDescriptorProto_TYPE_UINT64: + wire = "WireVarint" + pre, post = "b.EncodeVarint(uint64(", "))" + case descriptor.FieldDescriptorProto_TYPE_INT32, + descriptor.FieldDescriptorProto_TYPE_UINT32, + descriptor.FieldDescriptorProto_TYPE_ENUM: + wire = "WireVarint" + pre, post = "b.EncodeVarint(uint64(", "))" + case descriptor.FieldDescriptorProto_TYPE_FIXED64, + descriptor.FieldDescriptorProto_TYPE_SFIXED64: + wire = "WireFixed64" + pre, post = "b.EncodeFixed64(uint64(", "))" + case descriptor.FieldDescriptorProto_TYPE_FIXED32, + descriptor.FieldDescriptorProto_TYPE_SFIXED32: + wire = "WireFixed32" + pre, post = "b.EncodeFixed32(uint64(", "))" + case descriptor.FieldDescriptorProto_TYPE_BOOL: + // bool needs special handling. + g.P("t := uint64(0)") + g.P("if ", val, " { t = 1 }") + val = "t" + wire = "WireVarint" + pre, post = "b.EncodeVarint(", ")" + case descriptor.FieldDescriptorProto_TYPE_STRING: + wire = "WireBytes" + pre, post = "b.EncodeStringBytes(", ")" + case descriptor.FieldDescriptorProto_TYPE_GROUP: + wire = "WireStartGroup" + pre, post = "b.Marshal(", ")" + canFail = true + case descriptor.FieldDescriptorProto_TYPE_MESSAGE: + wire = "WireBytes" + pre, post = "b.EncodeMessage(", ")" + canFail = true + case descriptor.FieldDescriptorProto_TYPE_BYTES: + wire = "WireBytes" + pre, post = "b.EncodeRawBytes(", ")" + case descriptor.FieldDescriptorProto_TYPE_SINT32: + wire = "WireVarint" + pre, post = "b.EncodeZigzag32(uint64(", "))" + case descriptor.FieldDescriptorProto_TYPE_SINT64: + wire = "WireVarint" + pre, post = "b.EncodeZigzag64(uint64(", "))" + default: + g.Fail("unhandled oneof field type ", field.Type.String()) + } + fieldWire[field] = wire + g.P("_ = b.EncodeVarint(", field.Number, "<<3|", g.Pkg["proto"], ".", wire, ")") + if *field.Type == descriptor.FieldDescriptorProto_TYPE_BYTES && gogoproto.IsCustomType(field) { + g.P(`data, err := `, val, `.Marshal()`) + g.P(`if err != nil {`) + g.In() + g.P(`return err`) + g.Out() + g.P(`}`) + val = "data" + } + if !canFail { + g.P("_ = ", pre, val, post) + } else { + g.P("if err := ", pre, val, post, "; err != nil {") + g.In() + g.P("return err") + g.Out() + g.P("}") + } + if *field.Type == descriptor.FieldDescriptorProto_TYPE_GROUP { + g.P("_ = b.EncodeVarint(", field.Number, "<<3|", g.Pkg["proto"], ".WireEndGroup)") + } + } + g.P("case nil:") + g.P("default: return ", g.Pkg["fmt"], `.Errorf("`, ccTypeName, ".", fname, ` has unexpected type %T", x)`) + g.P("}") + } + g.P("return nil") + g.P("}") + g.P() + + // unmarshaler + g.P("func ", dec, decSig, " {") + g.P("m := msg.(*", ccTypeName, ")") + g.P("switch tag {") + for _, field := range message.Field { + if field.OneofIndex == nil { + continue + } + odp := message.OneofDecl[int(*field.OneofIndex)] + g.P("case ", field.Number, ": // ", odp.GetName(), ".", *field.Name) + g.P("if wire != ", g.Pkg["proto"], ".", fieldWire[field], " {") + g.P("return true, ", g.Pkg["proto"], ".ErrInternalBadWireType") + g.P("}") + lhs := "x, err" // overridden for TYPE_MESSAGE and TYPE_GROUP + var dec, cast, cast2 string + switch *field.Type { + case descriptor.FieldDescriptorProto_TYPE_DOUBLE: + dec, cast = "b.DecodeFixed64()", g.Pkg["math"]+".Float64frombits" + case descriptor.FieldDescriptorProto_TYPE_FLOAT: + dec, cast, cast2 = "b.DecodeFixed32()", "uint32", g.Pkg["math"]+".Float32frombits" + case descriptor.FieldDescriptorProto_TYPE_INT64: + dec, cast = "b.DecodeVarint()", "int64" + case descriptor.FieldDescriptorProto_TYPE_UINT64: + dec = "b.DecodeVarint()" + case descriptor.FieldDescriptorProto_TYPE_INT32: + dec, cast = "b.DecodeVarint()", "int32" + case descriptor.FieldDescriptorProto_TYPE_FIXED64: + dec = "b.DecodeFixed64()" + case descriptor.FieldDescriptorProto_TYPE_FIXED32: + dec, cast = "b.DecodeFixed32()", "uint32" + case descriptor.FieldDescriptorProto_TYPE_BOOL: + dec = "b.DecodeVarint()" + // handled specially below + case descriptor.FieldDescriptorProto_TYPE_STRING: + dec = "b.DecodeStringBytes()" + case descriptor.FieldDescriptorProto_TYPE_GROUP: + g.P("msg := new(", fieldTypes[field][1:], ")") // drop star + lhs = "err" + dec = "b.DecodeGroup(msg)" + // handled specially below + case descriptor.FieldDescriptorProto_TYPE_MESSAGE: + g.P("msg := new(", fieldTypes[field][1:], ")") // drop star + lhs = "err" + dec = "b.DecodeMessage(msg)" + // handled specially below + case descriptor.FieldDescriptorProto_TYPE_BYTES: + dec = "b.DecodeRawBytes(true)" + case descriptor.FieldDescriptorProto_TYPE_UINT32: + dec, cast = "b.DecodeVarint()", "uint32" + case descriptor.FieldDescriptorProto_TYPE_ENUM: + dec, cast = "b.DecodeVarint()", fieldTypes[field] + case descriptor.FieldDescriptorProto_TYPE_SFIXED32: + dec, cast = "b.DecodeFixed32()", "int32" + case descriptor.FieldDescriptorProto_TYPE_SFIXED64: + dec, cast = "b.DecodeFixed64()", "int64" + case descriptor.FieldDescriptorProto_TYPE_SINT32: + dec, cast = "b.DecodeZigzag32()", "int32" + case descriptor.FieldDescriptorProto_TYPE_SINT64: + dec, cast = "b.DecodeZigzag64()", "int64" + default: + g.Fail("unhandled oneof field type ", field.Type.String()) + } + g.P(lhs, " := ", dec) + val := "x" + if *field.Type == descriptor.FieldDescriptorProto_TYPE_BYTES && gogoproto.IsCustomType(field) { + g.P(`if err != nil {`) + g.In() + g.P(`return true, err`) + g.Out() + g.P(`}`) + _, ctyp, err := GetCustomType(field) + if err != nil { + panic(err) + } + g.P(`var cc `, ctyp) + g.P(`c := &cc`) + g.P(`err = c.Unmarshal(`, val, `)`) + val = "*c" + } + if cast != "" { + val = cast + "(" + val + ")" + } + if cast2 != "" { + val = cast2 + "(" + val + ")" + } + switch *field.Type { + case descriptor.FieldDescriptorProto_TYPE_BOOL: + val += " != 0" + case descriptor.FieldDescriptorProto_TYPE_GROUP, + descriptor.FieldDescriptorProto_TYPE_MESSAGE: + val = "msg" + } + if gogoproto.IsCastType(field) { + _, typ, err := getCastType(field) + if err != nil { + g.Fail(err.Error()) + } + val = typ + "(" + val + ")" + } + g.P("m.", oneofFieldName[*field.OneofIndex], " = &", oneofTypeName[field], "{", val, "}") + g.P("return true, err") + } + g.P("default: return false, nil") + g.P("}") + g.P("}") + g.P() + } + + for _, ext := range message.ext { + g.generateExtension(ext) + } + +} + +func (g *Generator) generateExtension(ext *ExtensionDescriptor) { + ccTypeName := ext.DescName() + + extObj := g.ObjectNamed(*ext.Extendee) + var extDesc *Descriptor + if id, ok := extObj.(*ImportedDescriptor); ok { + // This is extending a publicly imported message. + // We need the underlying type for goTag. + extDesc = id.o.(*Descriptor) + } else { + extDesc = extObj.(*Descriptor) + } + extendedType := "*" + g.TypeName(extObj) // always use the original + field := ext.FieldDescriptorProto + fieldType, wireType := g.GoType(ext.parent, field) + tag := g.goTag(extDesc, field, wireType) + g.RecordTypeUse(*ext.Extendee) + if n := ext.FieldDescriptorProto.TypeName; n != nil { + // foreign extension type + g.RecordTypeUse(*n) + } + + typeName := ext.TypeName() + + // Special case for proto2 message sets: If this extension is extending + // proto2_bridge.MessageSet, and its final name component is "message_set_extension", + // then drop that last component. + mset := false + if extendedType == "*proto2_bridge.MessageSet" && typeName[len(typeName)-1] == "message_set_extension" { + typeName = typeName[:len(typeName)-1] + mset = true + } + + // For text formatting, the package must be exactly what the .proto file declares, + // ignoring overrides such as the go_package option, and with no dot/underscore mapping. + extName := strings.Join(typeName, ".") + if g.file.Package != nil { + extName = *g.file.Package + "." + extName + } + + g.P("var ", ccTypeName, " = &", g.Pkg["proto"], ".ExtensionDesc{") + g.In() + g.P("ExtendedType: (", extendedType, ")(nil),") + g.P("ExtensionType: (", fieldType, ")(nil),") + g.P("Field: ", field.Number, ",") + g.P(`Name: "`, extName, `",`) + g.P("Tag: ", tag, ",") + + g.Out() + g.P("}") + g.P() + + if mset { + // Generate a bit more code to register with message_set.go. + g.addInitf("%s.RegisterMessageSetType((%s)(nil), %d, %q)", g.Pkg["proto"], fieldType, *field.Number, extName) + } + + g.file.addExport(ext, constOrVarSymbol{ccTypeName, "var", ""}) +} + +func (g *Generator) generateInitFunction() { + for _, enum := range g.file.enum { + g.generateEnumRegistration(enum) + } + for _, d := range g.file.desc { + for _, ext := range d.ext { + g.generateExtensionRegistration(ext) + } + } + for _, ext := range g.file.ext { + g.generateExtensionRegistration(ext) + } + if len(g.init) == 0 { + return + } + g.P("func init() {") + g.In() + for _, l := range g.init { + g.P(l) + } + g.Out() + g.P("}") + g.init = nil +} + +func (g *Generator) generateEnumRegistration(enum *EnumDescriptor) { + // // We always print the full (proto-world) package name here. + pkg := enum.File().GetPackage() + if pkg != "" { + pkg += "." + } + // The full type name + typeName := enum.TypeName() + // The full type name, CamelCased. + ccTypeName := CamelCaseSlice(typeName) + g.addInitf("%s.RegisterEnum(%q, %[3]s_name, %[3]s_value)", g.Pkg["proto"], pkg+ccTypeName, ccTypeName) +} + +func (g *Generator) generateExtensionRegistration(ext *ExtensionDescriptor) { + g.addInitf("%s.RegisterExtension(%s)", g.Pkg["proto"], ext.DescName()) +} + +// And now lots of helper functions. + +// Is c an ASCII lower-case letter? +func isASCIILower(c byte) bool { + return 'a' <= c && c <= 'z' +} + +// Is c an ASCII digit? +func isASCIIDigit(c byte) bool { + return '0' <= c && c <= '9' +} + +// CamelCase returns the CamelCased name. +// If there is an interior underscore followed by a lower case letter, +// drop the underscore and convert the letter to upper case. +// There is a remote possibility of this rewrite causing a name collision, +// but it's so remote we're prepared to pretend it's nonexistent - since the +// C++ generator lowercases names, it's extremely unlikely to have two fields +// with different capitalizations. +// In short, _my_field_name_2 becomes XMyFieldName_2. +func CamelCase(s string) string { + if s == "" { + return "" + } + t := make([]byte, 0, 32) + i := 0 + if s[0] == '_' { + // Need a capital letter; drop the '_'. + t = append(t, 'X') + i++ + } + // Invariant: if the next letter is lower case, it must be converted + // to upper case. + // That is, we process a word at a time, where words are marked by _ or + // upper case letter. Digits are treated as words. + for ; i < len(s); i++ { + c := s[i] + if c == '_' && i+1 < len(s) && isASCIILower(s[i+1]) { + continue // Skip the underscore in s. + } + if isASCIIDigit(c) { + t = append(t, c) + continue + } + // Assume we have a letter now - if not, it's a bogus identifier. + // The next word is a sequence of characters that must start upper case. + if isASCIILower(c) { + c ^= ' ' // Make it a capital letter. + } + t = append(t, c) // Guaranteed not lower case. + // Accept lower case sequence that follows. + for i+1 < len(s) && isASCIILower(s[i+1]) { + i++ + t = append(t, s[i]) + } + } + return string(t) +} + +// CamelCaseSlice is like CamelCase, but the argument is a slice of strings to +// be joined with "_". +func CamelCaseSlice(elem []string) string { return CamelCase(strings.Join(elem, "_")) } + +// dottedSlice turns a sliced name into a dotted name. +func dottedSlice(elem []string) string { return strings.Join(elem, ".") } + +// Given a .proto file name, return the output name for the generated Go program. +func goFileName(name string) string { + ext := path.Ext(name) + if ext == ".proto" || ext == ".protodevel" { + name = name[0 : len(name)-len(ext)] + } + return name + ".pb.go" +} + +// Is this field optional? +func isOptional(field *descriptor.FieldDescriptorProto) bool { + return field.Label != nil && *field.Label == descriptor.FieldDescriptorProto_LABEL_OPTIONAL +} + +// Is this field required? +func isRequired(field *descriptor.FieldDescriptorProto) bool { + return field.Label != nil && *field.Label == descriptor.FieldDescriptorProto_LABEL_REQUIRED +} + +// Is this field repeated? +func isRepeated(field *descriptor.FieldDescriptorProto) bool { + return field.Label != nil && *field.Label == descriptor.FieldDescriptorProto_LABEL_REPEATED +} + +// badToUnderscore is the mapping function used to generate Go names from package names, +// which can be dotted in the input .proto file. It replaces non-identifier characters such as +// dot or dash with underscore. +func badToUnderscore(r rune) rune { + if unicode.IsLetter(r) || unicode.IsDigit(r) || r == '_' { + return r + } + return '_' +} + +// baseName returns the last path element of the name, with the last dotted suffix removed. +func baseName(name string) string { + // First, find the last element + if i := strings.LastIndex(name, "/"); i >= 0 { + name = name[i+1:] + } + // Now drop the suffix + if i := strings.LastIndex(name, "."); i >= 0 { + name = name[0:i] + } + return name +} + +// The SourceCodeInfo message describes the location of elements of a parsed +// .proto file by way of a "path", which is a sequence of integers that +// describe the route from a FileDescriptorProto to the relevant submessage. +// The path alternates between a field number of a repeated field, and an index +// into that repeated field. The constants below define the field numbers that +// are used. +// +// See descriptor.proto for more information about this. +const ( + // tag numbers in FileDescriptorProto + packagePath = 2 // package + messagePath = 4 // message_type + enumPath = 5 // enum_type + // tag numbers in DescriptorProto + messageFieldPath = 2 // field + messageMessagePath = 3 // nested_type + messageEnumPath = 4 // enum_type + messageOneofPath = 8 // oneof_decl + // tag numbers in EnumDescriptorProto + enumValuePath = 2 // value +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator/helper.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator/helper.go new file mode 100644 index 0000000000000000000000000000000000000000..fceec0c64419d807a76ce7e5cf3dbf77c5a97e8e --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator/helper.go @@ -0,0 +1,357 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 generator + +import ( + "bytes" + "go/parser" + "go/printer" + "go/token" + "strings" + + "path" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + descriptor "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + plugin "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/plugin" +) + +func (d *FileDescriptor) Messages() []*Descriptor { + return d.desc +} + +func (d *FileDescriptor) Enums() []*EnumDescriptor { + return d.enum +} + +func (d *Descriptor) IsGroup() bool { + return d.group +} + +func (g *Generator) IsGroup(field *descriptor.FieldDescriptorProto) bool { + if d, ok := g.typeNameToObject[field.GetTypeName()].(*Descriptor); ok { + return d.IsGroup() + } + return false +} + +func (g *Generator) TypeNameByObject(typeName string) Object { + o, ok := g.typeNameToObject[typeName] + if !ok { + g.Fail("can't find object with type", typeName) + } + return o +} + +func (g *Generator) OneOfTypeName(message *Descriptor, field *descriptor.FieldDescriptorProto) string { + typeName := message.TypeName() + ccTypeName := CamelCaseSlice(typeName) + fieldName := g.GetOneOfFieldName(message, field) + tname := ccTypeName + "_" + fieldName + // It is possible for this to collide with a message or enum + // nested in this message. Check for collisions. + ok := true + for _, desc := range message.nested { + if strings.Join(desc.TypeName(), "_") == tname { + ok = false + break + } + } + for _, enum := range message.enums { + if strings.Join(enum.TypeName(), "_") == tname { + ok = false + break + } + } + if !ok { + tname += "_" + } + return tname +} + +type PluginImports interface { + NewImport(pkg string) Single + GenerateImports(file *FileDescriptor) +} + +type pluginImports struct { + generator *Generator + singles []Single +} + +func NewPluginImports(generator *Generator) *pluginImports { + return &pluginImports{generator, make([]Single, 0)} +} + +func (this *pluginImports) NewImport(pkg string) Single { + imp := newImportedPackage(this.generator.ImportPrefix, pkg) + this.singles = append(this.singles, imp) + return imp +} + +func (this *pluginImports) GenerateImports(file *FileDescriptor) { + for _, s := range this.singles { + if s.IsUsed() { + this.generator.PrintImport(s.Name(), s.Location()) + } + } +} + +type Single interface { + Use() string + IsUsed() bool + Name() string + Location() string +} + +type importedPackage struct { + used bool + pkg string + name string + importPrefix string +} + +func newImportedPackage(importPrefix, pkg string) *importedPackage { + return &importedPackage{ + pkg: pkg, + importPrefix: importPrefix, + } +} + +func (this *importedPackage) Use() string { + if !this.used { + this.name = RegisterUniquePackageName(this.pkg, nil) + this.used = true + } + return this.name +} + +func (this *importedPackage) IsUsed() bool { + return this.used +} + +func (this *importedPackage) Name() string { + return this.name +} + +func (this *importedPackage) Location() string { + return this.importPrefix + this.pkg +} + +func (g *Generator) GetFieldName(message *Descriptor, field *descriptor.FieldDescriptorProto) string { + goTyp, _ := g.GoType(message, field) + fieldname := CamelCase(*field.Name) + if gogoproto.IsCustomName(field) { + fieldname = gogoproto.GetCustomName(field) + } + if gogoproto.IsEmbed(field) { + fieldname = EmbedFieldName(goTyp) + } + if field.OneofIndex != nil { + fieldname = message.OneofDecl[int(*field.OneofIndex)].GetName() + fieldname = CamelCase(fieldname) + } + for _, f := range methodNames { + if f == fieldname { + return fieldname + "_" + } + } + return fieldname +} + +func (g *Generator) GetOneOfFieldName(message *Descriptor, field *descriptor.FieldDescriptorProto) string { + goTyp, _ := g.GoType(message, field) + fieldname := CamelCase(*field.Name) + if gogoproto.IsCustomName(field) { + fieldname = gogoproto.GetCustomName(field) + } + if gogoproto.IsEmbed(field) { + fieldname = EmbedFieldName(goTyp) + } + for _, f := range methodNames { + if f == fieldname { + return fieldname + "_" + } + } + return fieldname +} + +func GetMap(file *descriptor.FileDescriptorProto, field *descriptor.FieldDescriptorProto) *descriptor.DescriptorProto { + if !field.IsMessage() { + return nil + } + typeName := strings.TrimPrefix(field.GetTypeName(), "."+file.GetPackage()+".") + if strings.Contains(typeName, "Map") && !strings.HasSuffix(typeName, "Entry") { + typeName += "." + CamelCase(field.GetName()) + "Entry" + } + return file.GetMessage(typeName) +} + +func IsMap(file *descriptor.FileDescriptorProto, field *descriptor.FieldDescriptorProto) bool { + msg := GetMap(file, field) + if msg == nil { + return false + } + return msg.GetOptions().GetMapEntry() +} + +func GoTypeToName(goTyp string) string { + return strings.Replace(strings.Replace(goTyp, "*", "", -1), "[]", "", -1) +} + +func EmbedFieldName(goTyp string) string { + goTyp = GoTypeToName(goTyp) + goTyps := strings.Split(goTyp, ".") + if len(goTyps) == 1 { + return goTyp + } + if len(goTyps) == 2 { + return goTyps[1] + } + panic("unreachable") +} + +func (g *Generator) GeneratePlugin(p Plugin) { + p.Init(g) + // Generate the output. The generator runs for every file, even the files + // that we don't generate output for, so that we can collate the full list + // of exported symbols to support public imports. + genFileMap := make(map[*FileDescriptor]bool, len(g.genFiles)) + for _, file := range g.genFiles { + genFileMap[file] = true + } + i := 0 + for _, file := range g.allFiles { + g.Reset() + g.generatePlugin(file, p) + if _, ok := genFileMap[file]; !ok { + continue + } + g.Response.File[i] = new(plugin.CodeGeneratorResponse_File) + g.Response.File[i].Name = proto.String(goFileName(*file.Name)) + g.Response.File[i].Content = proto.String(g.String()) + i++ + } +} + +func (g *Generator) SetFile(file *descriptor.FileDescriptorProto) { + g.file = g.FileOf(file) +} + +func (g *Generator) generatePlugin(file *FileDescriptor, p Plugin) { + g.writtenImports = make(map[string]bool) + g.file = g.FileOf(file.FileDescriptorProto) + g.usedPackages = make(map[string]bool) + + // Run the plugins before the imports so we know which imports are necessary. + p.Generate(file) + + // Generate header and imports last, though they appear first in the output. + rem := g.Buffer + g.Buffer = new(bytes.Buffer) + g.generateHeader() + p.GenerateImports(g.file) + g.generateImports() + g.Write(rem.Bytes()) + + // Reformat generated code. + contents := string(g.Buffer.Bytes()) + fset := token.NewFileSet() + ast, err := parser.ParseFile(fset, "", g, parser.ParseComments) + if err != nil { + g.Fail("bad Go source code was generated:", contents, err.Error()) + return + } + g.Reset() + err = (&printer.Config{Mode: printer.TabIndent | printer.UseSpaces, Tabwidth: 8}).Fprint(g, fset, ast) + if err != nil { + g.Fail("generated Go source code could not be reformatted:", err.Error()) + } +} + +func GetCustomType(field *descriptor.FieldDescriptorProto) (packageName string, typ string, err error) { + return getCustomType(field) +} + +func getCustomType(field *descriptor.FieldDescriptorProto) (packageName string, typ string, err error) { + if field.Options != nil { + var v interface{} + v, err = proto.GetExtension(field.Options, gogoproto.E_Customtype) + if err == nil && v.(*string) != nil { + ctype := *(v.(*string)) + packageName, typ = splitCPackageType(ctype) + return packageName, typ, nil + } + } + return "", "", err +} + +func splitCPackageType(ctype string) (packageName string, typ string) { + ss := strings.Split(ctype, ".") + if len(ss) == 1 { + return "", ctype + } + packageName = strings.Join(ss[0:len(ss)-1], ".") + typeName := ss[len(ss)-1] + importStr := strings.Map(badToUnderscore, packageName) + typ = importStr + "." + typeName + return packageName, typ +} + +func getCastType(field *descriptor.FieldDescriptorProto) (packageName string, typ string, err error) { + if field.Options != nil { + var v interface{} + v, err = proto.GetExtension(field.Options, gogoproto.E_Casttype) + if err == nil && v.(*string) != nil { + ctype := *(v.(*string)) + packageName, typ = splitCPackageType(ctype) + return packageName, typ, nil + } + } + return "", "", err +} + +func FileName(file *FileDescriptor) string { + fname := path.Base(file.FileDescriptorProto.GetName()) + fname = strings.Replace(fname, ".proto", "", -1) + fname = strings.Replace(fname, "-", "_", -1) + return CamelCase(fname) +} + +func (g *Generator) AllFiles() *descriptor.FileDescriptorSet { + set := &descriptor.FileDescriptorSet{} + set.File = make([]*descriptor.FileDescriptorProto, len(g.allFiles)) + for i := range g.allFiles { + set.File[i] = g.allFiles[i].FileDescriptorProto + } + return set +} + +func (d *Descriptor) Path() string { + return d.path +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator/name_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator/name_test.go new file mode 100644 index 0000000000000000000000000000000000000000..f926918e4d4aafe0676c7799f9887d9de1a4a40e --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator/name_test.go @@ -0,0 +1,56 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2013 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 generator + +import ( + "testing" +) + +func TestCamelCase(t *testing.T) { + tests := []struct { + in, want string + }{ + {"one", "One"}, + {"one_two", "OneTwo"}, + {"_my_field_name_2", "XMyFieldName_2"}, + {"Something_Capped", "Something_Capped"}, + {"my_Name", "My_Name"}, + {"OneTwo", "OneTwo"}, + {"_", "X"}, + {"_a_", "XA_"}, + } + for _, tc := range tests { + if got := CamelCase(tc.in); got != tc.want { + t.Errorf("CamelCase(%q) = %q, want %q", tc.in, got, tc.want) + } + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/main.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/main.go new file mode 100644 index 0000000000000000000000000000000000000000..437907c1ec4b44de75104a6a3decf35a8e56b86e --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/main.go @@ -0,0 +1,57 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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. + +// protoc-gen-go is a plugin for the Google protocol buffer compiler to generate +// Go code. Run it by building this program and putting it in your path with +// the name +// protoc-gen-gogo +// That word 'gogo' at the end becomes part of the option string set for the +// protocol compiler, so once the protocol compiler (protoc) is installed +// you can run +// protoc --gogo_out=output_directory input_directory/file.proto +// to generate Go bindings for the protocol defined by file.proto. +// With that input, the output will be written to +// output_directory/file.pb.go +// +// The generated code is documented in the package comment for +// the library. +// +// See the README and documentation for protocol buffers to learn more: +// https://developers.google.com/protocol-buffers/ +package main + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/command" +) + +func main() { + command.Write(command.Generate(command.Read())) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/plugin/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/plugin/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..546287cef8a187599910d639299030792682a6fc --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/plugin/Makefile @@ -0,0 +1,37 @@ +# Go support for Protocol Buffers - Google's data interchange format +# +# Copyright 2010 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. + +# Not stored here, but plugin.proto is in https://github.com/google/protobuf/ +# at src/google/protobuf/compiler/plugin.proto +# Also we need to fix an import. +regenerate: + protoc --gogo_out=Mgoogle/protobuf/descriptor.proto=github.com/gogo/protobuf/protoc-gen-gogo/descriptor:. -I=../../protobuf/google/protobuf/compiler/:../../protobuf/ ../../protobuf/google/protobuf/compiler/plugin.proto + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/plugin/plugin.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/plugin/plugin.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..c5bb52e2aa419c81a7a550b8a9dfad0d49592e14 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/plugin/plugin.pb.go @@ -0,0 +1,188 @@ +// Code generated by protoc-gen-gogo. +// source: plugin.proto +// DO NOT EDIT! + +/* +Package google_protobuf_compiler is a generated protocol buffer package. + +It is generated from these files: + plugin.proto + +It has these top-level messages: + CodeGeneratorRequest + CodeGeneratorResponse +*/ +package google_protobuf_compiler + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// An encoded CodeGeneratorRequest is written to the plugin's stdin. +type CodeGeneratorRequest struct { + // The .proto files that were explicitly listed on the command-line. The + // code generator should generate code only for these files. Each file's + // descriptor will be included in proto_file, below. + FileToGenerate []string `protobuf:"bytes,1,rep,name=file_to_generate" json:"file_to_generate,omitempty"` + // The generator parameter passed on the command-line. + Parameter *string `protobuf:"bytes,2,opt,name=parameter" json:"parameter,omitempty"` + // FileDescriptorProtos for all files in files_to_generate and everything + // they import. The files will appear in topological order, so each file + // appears before any file that imports it. + // + // protoc guarantees that all proto_files will be written after + // the fields above, even though this is not technically guaranteed by the + // protobuf wire format. This theoretically could allow a plugin to stream + // in the FileDescriptorProtos and handle them one by one rather than read + // the entire set into memory at once. However, as of this writing, this + // is not similarly optimized on protoc's end -- it will store all fields in + // memory at once before sending them to the plugin. + ProtoFile []*google_protobuf.FileDescriptorProto `protobuf:"bytes,15,rep,name=proto_file" json:"proto_file,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CodeGeneratorRequest) Reset() { *m = CodeGeneratorRequest{} } +func (m *CodeGeneratorRequest) String() string { return proto.CompactTextString(m) } +func (*CodeGeneratorRequest) ProtoMessage() {} + +func (m *CodeGeneratorRequest) GetFileToGenerate() []string { + if m != nil { + return m.FileToGenerate + } + return nil +} + +func (m *CodeGeneratorRequest) GetParameter() string { + if m != nil && m.Parameter != nil { + return *m.Parameter + } + return "" +} + +func (m *CodeGeneratorRequest) GetProtoFile() []*google_protobuf.FileDescriptorProto { + if m != nil { + return m.ProtoFile + } + return nil +} + +// The plugin writes an encoded CodeGeneratorResponse to stdout. +type CodeGeneratorResponse struct { + // Error message. If non-empty, code generation failed. The plugin process + // should exit with status code zero even if it reports an error in this way. + // + // This should be used to indicate errors in .proto files which prevent the + // code generator from generating correct code. Errors which indicate a + // problem in protoc itself -- such as the input CodeGeneratorRequest being + // unparseable -- should be reported by writing a message to stderr and + // exiting with a non-zero status code. + Error *string `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"` + File []*CodeGeneratorResponse_File `protobuf:"bytes,15,rep,name=file" json:"file,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CodeGeneratorResponse) Reset() { *m = CodeGeneratorResponse{} } +func (m *CodeGeneratorResponse) String() string { return proto.CompactTextString(m) } +func (*CodeGeneratorResponse) ProtoMessage() {} + +func (m *CodeGeneratorResponse) GetError() string { + if m != nil && m.Error != nil { + return *m.Error + } + return "" +} + +func (m *CodeGeneratorResponse) GetFile() []*CodeGeneratorResponse_File { + if m != nil { + return m.File + } + return nil +} + +// Represents a single generated file. +type CodeGeneratorResponse_File struct { + // The file name, relative to the output directory. The name must not + // contain "." or ".." components and must be relative, not be absolute (so, + // the file cannot lie outside the output directory). "/" must be used as + // the path separator, not "\". + // + // If the name is omitted, the content will be appended to the previous + // file. This allows the generator to break large files into small chunks, + // and allows the generated text to be streamed back to protoc so that large + // files need not reside completely in memory at one time. Note that as of + // this writing protoc does not optimize for this -- it will read the entire + // CodeGeneratorResponse before writing files to disk. + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + // If non-empty, indicates that the named file should already exist, and the + // content here is to be inserted into that file at a defined insertion + // point. This feature allows a code generator to extend the output + // produced by another code generator. The original generator may provide + // insertion points by placing special annotations in the file that look + // like: + // @@protoc_insertion_point(NAME) + // The annotation can have arbitrary text before and after it on the line, + // which allows it to be placed in a comment. NAME should be replaced with + // an identifier naming the point -- this is what other generators will use + // as the insertion_point. Code inserted at this point will be placed + // immediately above the line containing the insertion point (thus multiple + // insertions to the same point will come out in the order they were added). + // The double-@ is intended to make it unlikely that the generated code + // could contain things that look like insertion points by accident. + // + // For example, the C++ code generator places the following line in the + // .pb.h files that it generates: + // // @@protoc_insertion_point(namespace_scope) + // This line appears within the scope of the file's package namespace, but + // outside of any particular class. Another plugin can then specify the + // insertion_point "namespace_scope" to generate additional classes or + // other declarations that should be placed in this scope. + // + // Note that if the line containing the insertion point begins with + // whitespace, the same whitespace will be added to every line of the + // inserted text. This is useful for languages like Python, where + // indentation matters. In these languages, the insertion point comment + // should be indented the same amount as any inserted code will need to be + // in order to work correctly in that context. + // + // The code generator that generates the initial file and the one which + // inserts into it must both run as part of a single invocation of protoc. + // Code generators are executed in the order in which they appear on the + // command line. + // + // If |insertion_point| is present, |name| must also be present. + InsertionPoint *string `protobuf:"bytes,2,opt,name=insertion_point" json:"insertion_point,omitempty"` + // The file contents. + Content *string `protobuf:"bytes,15,opt,name=content" json:"content,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CodeGeneratorResponse_File) Reset() { *m = CodeGeneratorResponse_File{} } +func (m *CodeGeneratorResponse_File) String() string { return proto.CompactTextString(m) } +func (*CodeGeneratorResponse_File) ProtoMessage() {} + +func (m *CodeGeneratorResponse_File) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CodeGeneratorResponse_File) GetInsertionPoint() string { + if m != nil && m.InsertionPoint != nil { + return *m.InsertionPoint + } + return "" +} + +func (m *CodeGeneratorResponse_File) GetContent() string { + if m != nil && m.Content != nil { + return *m.Content + } + return "" +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..dfc51095dd860293b2a95728c989efe28093db8d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/Makefile @@ -0,0 +1,65 @@ +# Go support for Protocol Buffers - Google's data interchange format +# +# Copyright 2010 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. + +all: + @echo run make test + +test: golden testbuild + +#test: golden testbuild extension_test +# ./extension_test +# @echo PASS + +golden: + go install github.com/gogo/protobuf/protoc-min-version + protoc-min-version --version="3.0.0" --gogo_out=. ./my_test/test.proto + diff -w my_test/test.pb.go my_test/test.pb.go.golden + +nuke: clean + +testbuild: buildprotos + go test + +buildprotos: + # Invoke protoc once to generate three independent .pb.go files in the same package. + protoc --gogo_out=. multi/multi{1,2,3}.proto + +#extension_test: extension_test.$O +# $(LD) -L. -o $@ $< + +#multi.a: multi3.pb.$O multi2.pb.$O multi1.pb.$O +# rm -f multi.a +# $(QUOTED_GOBIN)/gopack grc $@ $< + +#test.pb.go: imp.pb.go +#multi1.pb.go: multi2.pb.go multi3.pb.go +#main.$O: imp.pb.$O test.pb.$O multi.a +#extension_test.$O: extension_base.pb.$O extension_extra.pb.$O extension_user.pb.$O diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/extension_base.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/extension_base.proto new file mode 100644 index 0000000000000000000000000000000000000000..94acfc1bc926231d2437de05baf5013e3d5ccd43 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/extension_base.proto @@ -0,0 +1,46 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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"; + +package extension_base; + +message BaseMessage { + optional int32 height = 1; + extensions 4 to 9; + extensions 16 to max; +} + +// Another message that may be extended, using message_set_wire_format. +message OldStyleMessage { + option message_set_wire_format = true; + extensions 100 to max; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/extension_extra.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/extension_extra.proto new file mode 100644 index 0000000000000000000000000000000000000000..fca7f600cc7f024234b8a9c04c6c59d75b5014fb --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/extension_extra.proto @@ -0,0 +1,38 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2011 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"; + +package extension_extra; + +message ExtraMessage { + optional int32 width = 1; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/extension_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/extension_test.go new file mode 100644 index 0000000000000000000000000000000000000000..86e9c118a6f7d1ce1a39734aaebe902a0e72880f --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/extension_test.go @@ -0,0 +1,210 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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. + +// Test that we can use protocol buffers that use extensions. + +package testdata + +/* + +import ( + "bytes" + "regexp" + "testing" + + "github.com/golang/protobuf/proto" + base "extension_base.pb" + user "extension_user.pb" +) + +func TestSingleFieldExtension(t *testing.T) { + bm := &base.BaseMessage{ + Height: proto.Int32(178), + } + + // Use extension within scope of another type. + vol := proto.Uint32(11) + err := proto.SetExtension(bm, user.E_LoudMessage_Volume, vol) + if err != nil { + t.Fatal("Failed setting extension:", err) + } + buf, err := proto.Marshal(bm) + if err != nil { + t.Fatal("Failed encoding message with extension:", err) + } + bm_new := new(base.BaseMessage) + if err := proto.Unmarshal(buf, bm_new); err != nil { + t.Fatal("Failed decoding message with extension:", err) + } + if !proto.HasExtension(bm_new, user.E_LoudMessage_Volume) { + t.Fatal("Decoded message didn't contain extension.") + } + vol_out, err := proto.GetExtension(bm_new, user.E_LoudMessage_Volume) + if err != nil { + t.Fatal("Failed getting extension:", err) + } + if v := vol_out.(*uint32); *v != *vol { + t.Errorf("vol_out = %v, expected %v", *v, *vol) + } + proto.ClearExtension(bm_new, user.E_LoudMessage_Volume) + if proto.HasExtension(bm_new, user.E_LoudMessage_Volume) { + t.Fatal("Failed clearing extension.") + } +} + +func TestMessageExtension(t *testing.T) { + bm := &base.BaseMessage{ + Height: proto.Int32(179), + } + + // Use extension that is itself a message. + um := &user.UserMessage{ + Name: proto.String("Dave"), + Rank: proto.String("Major"), + } + err := proto.SetExtension(bm, user.E_LoginMessage_UserMessage, um) + if err != nil { + t.Fatal("Failed setting extension:", err) + } + buf, err := proto.Marshal(bm) + if err != nil { + t.Fatal("Failed encoding message with extension:", err) + } + bm_new := new(base.BaseMessage) + if err := proto.Unmarshal(buf, bm_new); err != nil { + t.Fatal("Failed decoding message with extension:", err) + } + if !proto.HasExtension(bm_new, user.E_LoginMessage_UserMessage) { + t.Fatal("Decoded message didn't contain extension.") + } + um_out, err := proto.GetExtension(bm_new, user.E_LoginMessage_UserMessage) + if err != nil { + t.Fatal("Failed getting extension:", err) + } + if n := um_out.(*user.UserMessage).Name; *n != *um.Name { + t.Errorf("um_out.Name = %q, expected %q", *n, *um.Name) + } + if r := um_out.(*user.UserMessage).Rank; *r != *um.Rank { + t.Errorf("um_out.Rank = %q, expected %q", *r, *um.Rank) + } + proto.ClearExtension(bm_new, user.E_LoginMessage_UserMessage) + if proto.HasExtension(bm_new, user.E_LoginMessage_UserMessage) { + t.Fatal("Failed clearing extension.") + } +} + +func TestTopLevelExtension(t *testing.T) { + bm := &base.BaseMessage{ + Height: proto.Int32(179), + } + + width := proto.Int32(17) + err := proto.SetExtension(bm, user.E_Width, width) + if err != nil { + t.Fatal("Failed setting extension:", err) + } + buf, err := proto.Marshal(bm) + if err != nil { + t.Fatal("Failed encoding message with extension:", err) + } + bm_new := new(base.BaseMessage) + if err := proto.Unmarshal(buf, bm_new); err != nil { + t.Fatal("Failed decoding message with extension:", err) + } + if !proto.HasExtension(bm_new, user.E_Width) { + t.Fatal("Decoded message didn't contain extension.") + } + width_out, err := proto.GetExtension(bm_new, user.E_Width) + if err != nil { + t.Fatal("Failed getting extension:", err) + } + if w := width_out.(*int32); *w != *width { + t.Errorf("width_out = %v, expected %v", *w, *width) + } + proto.ClearExtension(bm_new, user.E_Width) + if proto.HasExtension(bm_new, user.E_Width) { + t.Fatal("Failed clearing extension.") + } +} + +func TestMessageSetWireFormat(t *testing.T) { + osm := new(base.OldStyleMessage) + osp := &user.OldStyleParcel{ + Name: proto.String("Dave"), + Height: proto.Int32(178), + } + + err := proto.SetExtension(osm, user.E_OldStyleParcel_MessageSetExtension, osp) + if err != nil { + t.Fatal("Failed setting extension:", err) + } + + buf, err := proto.Marshal(osm) + if err != nil { + t.Fatal("Failed encoding message:", err) + } + + // Data generated from Python implementation. + expected := []byte{ + 11, 16, 209, 15, 26, 9, 10, 4, 68, 97, 118, 101, 16, 178, 1, 12, + } + + if !bytes.Equal(expected, buf) { + t.Errorf("Encoding mismatch.\nwant %+v\n got %+v", expected, buf) + } + + // Check that it is restored correctly. + osm = new(base.OldStyleMessage) + if err := proto.Unmarshal(buf, osm); err != nil { + t.Fatal("Failed decoding message:", err) + } + osp_out, err := proto.GetExtension(osm, user.E_OldStyleParcel_MessageSetExtension) + if err != nil { + t.Fatal("Failed getting extension:", err) + } + osp = osp_out.(*user.OldStyleParcel) + if *osp.Name != "Dave" || *osp.Height != 178 { + t.Errorf("Retrieved extension from decoded message is not correct: %+v", osp) + } +} + +func main() { + // simpler than rigging up gotest + testing.Main(regexp.MatchString, []testing.InternalTest{ + {"TestSingleFieldExtension", TestSingleFieldExtension}, + {"TestMessageExtension", TestMessageExtension}, + {"TestTopLevelExtension", TestTopLevelExtension}, + }, + []testing.InternalBenchmark{}, + []testing.InternalExample{}) +} + +*/ diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/extension_user.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/extension_user.proto new file mode 100644 index 0000000000000000000000000000000000000000..ff65873dd2d2c9ee3874170d847a60962c405a87 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/extension_user.proto @@ -0,0 +1,100 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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 "extension_base.proto"; +import "extension_extra.proto"; + +package extension_user; + +message UserMessage { + optional string name = 1; + optional string rank = 2; +} + +// Extend with a message +extend extension_base.BaseMessage { + optional UserMessage user_message = 5; +} + +// Extend with a foreign message +extend extension_base.BaseMessage { + optional extension_extra.ExtraMessage extra_message = 9; +} + +// Extend with some primitive types +extend extension_base.BaseMessage { + optional int32 width = 6; + optional int64 area = 7; +} + +// Extend inside the scope of another type +message LoudMessage { + extend extension_base.BaseMessage { + optional uint32 volume = 8; + } + extensions 100 to max; +} + +// Extend inside the scope of another type, using a message. +message LoginMessage { + extend extension_base.BaseMessage { + optional UserMessage user_message = 16; + } +} + +// Extend with a repeated field +extend extension_base.BaseMessage { + repeated Detail detail = 17; +} + +message Detail { + optional string color = 1; +} + +// An extension of an extension +message Announcement { + optional string words = 1; + extend LoudMessage { + optional Announcement loud_ext = 100; + } +} + +// Something that can be put in a message set. +message OldStyleParcel { + extend extension_base.OldStyleMessage { + optional OldStyleParcel message_set_extension = 2001; + } + + required string name = 1; + optional int32 height = 2; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/golden_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/golden_test.go new file mode 100644 index 0000000000000000000000000000000000000000..01772d52eabf7b255f5ee8fa2bb7ef2e13f5517c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/golden_test.go @@ -0,0 +1,86 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2012 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. + +// Verify that the compiler output for test.proto is unchanged. + +package testdata + +import ( + "crypto/sha1" + "fmt" + "io/ioutil" + "os" + "os/exec" + "path/filepath" + "testing" +) + +// sum returns in string form (for easy comparison) the SHA-1 hash of the named file. +func sum(t *testing.T, name string) string { + data, err := ioutil.ReadFile(name) + if err != nil { + t.Fatal(err) + } + t.Logf("sum(%q): length is %d", name, len(data)) + hash := sha1.New() + _, err = hash.Write(data) + if err != nil { + t.Fatal(err) + } + return fmt.Sprintf("% x", hash.Sum(nil)) +} + +func run(t *testing.T, name string, args ...string) { + cmd := exec.Command(name, args...) + cmd.Stdin = os.Stdin + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + err := cmd.Run() + if err != nil { + t.Fatal(err) + } +} + +func TestGolden(t *testing.T) { + // Compute the original checksum. + goldenSum := sum(t, "my_test/test.pb.go") + // Run the proto compiler. + run(t, "protoc", "--gogo_out="+os.TempDir(), "my_test/test.proto") + newFile := filepath.Join(os.TempDir(), "my_test/test.pb.go") + defer os.Remove(newFile) + // Compute the new checksum. + newSum := sum(t, newFile) + // Verify + if newSum != goldenSum { + run(t, "diff", "-u", "my_test/test.pb.go", newFile) + t.Fatal("Code generated by protoc-gen-go has changed; update test.pb.go") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/grpc.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/grpc.proto new file mode 100644 index 0000000000000000000000000000000000000000..b8bc41acd87db6a87b75b7484cc9bb1375131395 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/grpc.proto @@ -0,0 +1,59 @@ +// 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 grpc.testing; + +message SimpleRequest { +} + +message SimpleResponse { +} + +message StreamMsg { +} + +message StreamMsg2 { +} + +service Test { + rpc UnaryCall(SimpleRequest) returns (SimpleResponse); + + // This RPC streams from the server only. + rpc Downstream(SimpleRequest) returns (stream StreamMsg); + + // This RPC streams from the client. + rpc Upstream(stream StreamMsg) returns (SimpleResponse); + + // This one streams in both directions. + rpc Bidi(stream StreamMsg) returns (stream StreamMsg2); +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/imp.pb.go.golden b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/imp.pb.go.golden new file mode 100644 index 0000000000000000000000000000000000000000..784a4f865a5f3ab7e7aa3f2a504f8fb88cfd6c7f --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/imp.pb.go.golden @@ -0,0 +1,113 @@ +// Code generated by protoc-gen-go. +// source: imp.proto +// DO NOT EDIT! + +package imp + +import proto "github.com/golang/protobuf/proto" +import "math" +import "os" +import imp1 "imp2.pb" + +// Reference proto & math imports to suppress error if they are not otherwise used. +var _ = proto.GetString +var _ = math.Inf + +// Types from public import imp2.proto +type PubliclyImportedMessage imp1.PubliclyImportedMessage + +func (this *PubliclyImportedMessage) Reset() { (*imp1.PubliclyImportedMessage)(this).Reset() } +func (this *PubliclyImportedMessage) String() string { + return (*imp1.PubliclyImportedMessage)(this).String() +} + +// PubliclyImportedMessage from public import imp.proto + +type ImportedMessage_Owner int32 + +const ( + ImportedMessage_DAVE ImportedMessage_Owner = 1 + ImportedMessage_MIKE ImportedMessage_Owner = 2 +) + +var ImportedMessage_Owner_name = map[int32]string{ + 1: "DAVE", + 2: "MIKE", +} +var ImportedMessage_Owner_value = map[string]int32{ + "DAVE": 1, + "MIKE": 2, +} + +// NewImportedMessage_Owner is deprecated. Use x.Enum() instead. +func NewImportedMessage_Owner(x ImportedMessage_Owner) *ImportedMessage_Owner { + e := ImportedMessage_Owner(x) + return &e +} +func (x ImportedMessage_Owner) Enum() *ImportedMessage_Owner { + p := new(ImportedMessage_Owner) + *p = x + return p +} +func (x ImportedMessage_Owner) String() string { + return proto.EnumName(ImportedMessage_Owner_name, int32(x)) +} + +type ImportedMessage struct { + Field *int64 `protobuf:"varint,1,req,name=field" json:"field,omitempty"` + XXX_extensions map[int32][]byte `json:",omitempty"` + XXX_unrecognized []byte `json:",omitempty"` +} + +func (this *ImportedMessage) Reset() { *this = ImportedMessage{} } +func (this *ImportedMessage) String() string { return proto.CompactTextString(this) } + +var extRange_ImportedMessage = []proto.ExtensionRange{ + proto.ExtensionRange{90, 100}, +} + +func (*ImportedMessage) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_ImportedMessage +} +func (this *ImportedMessage) ExtensionMap() map[int32][]byte { + if this.XXX_extensions == nil { + this.XXX_extensions = make(map[int32][]byte) + } + return this.XXX_extensions +} + +type ImportedExtendable struct { + XXX_extensions map[int32][]byte `json:",omitempty"` + XXX_unrecognized []byte `json:",omitempty"` +} + +func (this *ImportedExtendable) Reset() { *this = ImportedExtendable{} } +func (this *ImportedExtendable) String() string { return proto.CompactTextString(this) } + +func (this *ImportedExtendable) Marshal() ([]byte, error) { + return proto.MarshalMessageSet(this.ExtensionMap()) +} +func (this *ImportedExtendable) Unmarshal(buf []byte) error { + return proto.UnmarshalMessageSet(buf, this.ExtensionMap()) +} +// ensure ImportedExtendable satisfies proto.Marshaler and proto.Unmarshaler +var _ proto.Marshaler = (*ImportedExtendable)(nil) +var _ proto.Unmarshaler = (*ImportedExtendable)(nil) + +var extRange_ImportedExtendable = []proto.ExtensionRange{ + proto.ExtensionRange{100, 536870911}, +} + +func (*ImportedExtendable) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_ImportedExtendable +} +func (this *ImportedExtendable) ExtensionMap() map[int32][]byte { + if this.XXX_extensions == nil { + this.XXX_extensions = make(map[int32][]byte) + } + return this.XXX_extensions +} + +func init() { + proto.RegisterEnum("imp.ImportedMessage_Owner", ImportedMessage_Owner_name, ImportedMessage_Owner_value) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/imp.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/imp.proto new file mode 100644 index 0000000000000000000000000000000000000000..83f97d5a27cfc0f2d63dd2e92650f8f896807493 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/imp.proto @@ -0,0 +1,67 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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"; + +package imp; + +import "imp2.proto"; +import "imp3.proto"; + +message ImportedMessage { + required int64 field = 1; + + // The forwarded getters for these fields are fiddly to get right. + optional ImportedMessage2 local_msg = 2; + optional ForeignImportedMessage foreign_msg = 3; // in imp3.proto + optional Owner enum_field = 4; + + repeated string name = 5; + repeated Owner boss = 6; + repeated ImportedMessage2 memo = 7; + + map msg_map = 8; + + enum Owner { + DAVE = 1; + MIKE = 2; + } + + extensions 90 to 100; +} + +message ImportedMessage2 { +} + +message ImportedExtendable { + option message_set_wire_format = true; + extensions 100 to max; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/imp2.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/imp2.proto new file mode 100644 index 0000000000000000000000000000000000000000..3bb0632b29599adb8fc4e351958fe3e274e41cc5 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/imp2.proto @@ -0,0 +1,43 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2011 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"; + +package imp; + +message PubliclyImportedMessage { + optional int64 field = 1; +} + +enum PubliclyImportedEnum { + GLASSES = 1; + HAIR = 2; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/imp3.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/imp3.proto new file mode 100644 index 0000000000000000000000000000000000000000..58fc7598bf9675fdf994229a1a74897f33ea6a8f --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/imp3.proto @@ -0,0 +1,38 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2012 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"; + +package imp; + +message ForeignImportedMessage { + optional string tuber = 1; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/main_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/main_test.go new file mode 100644 index 0000000000000000000000000000000000000000..2f1711c50545f97866f20ae3481358bad1d84529 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/main_test.go @@ -0,0 +1,46 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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. + +// A simple binary to link together the protocol buffers in this test. + +package testdata + +import ( + "testing" + + multipb "./multi" + mytestpb "./my_test" +) + +func TestLink(t *testing.T) { + _ = &multipb.Multi1{} + _ = &mytestpb.Request{} +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/multi/.gitignore b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/multi/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..c61a5e8b01255cc9de6912fd74b6819c53d3aca2 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/multi/.gitignore @@ -0,0 +1 @@ +*.pb.go diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/multi/multi1.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/multi/multi1.proto new file mode 100644 index 0000000000000000000000000000000000000000..0da6e0af4b2a30122d4c0e238f04d2040e2791f1 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/multi/multi1.proto @@ -0,0 +1,44 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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 "multi/multi2.proto"; +import "multi/multi3.proto"; + +package multitest; + +message Multi1 { + required Multi2 multi2 = 1; + optional Multi2.Color color = 2; + optional Multi3.HatType hat_type = 3; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/multi/multi2.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/multi/multi2.proto new file mode 100644 index 0000000000000000000000000000000000000000..e6bfc71b3c0ec693fd5ef627fbe99a00124a20f3 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/multi/multi2.proto @@ -0,0 +1,46 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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"; + +package multitest; + +message Multi2 { + required int32 required_value = 1; + + enum Color { + BLUE = 1; + GREEN = 2; + RED = 3; + }; + optional Color color = 2; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/multi/multi3.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/multi/multi3.proto new file mode 100644 index 0000000000000000000000000000000000000000..146c255bd215c691f1bedb7ad602e3052a14da6a --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/multi/multi3.proto @@ -0,0 +1,43 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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"; + +package multitest; + +message Multi3 { + enum HatType { + FEDORA = 1; + FEZ = 2; + }; + optional HatType hat_type = 1; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/my_test/test.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/my_test/test.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..58fde0fce8c96eb7837044efe451a91b5e5611fe --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/my_test/test.pb.go @@ -0,0 +1,822 @@ +// Code generated by protoc-gen-gogo. +// source: my_test/test.proto +// DO NOT EDIT! + +/* +Package my_test is a generated protocol buffer package. + +This package holds interesting messages. + +It is generated from these files: + my_test/test.proto + +It has these top-level messages: + Request + Reply + OtherBase + ReplyExtensions + OtherReplyExtensions + OldReply + Communique +*/ +package my_test + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import multitest2 "multi" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type HatType int32 + +const ( + // deliberately skipping 0 + HatType_FEDORA HatType = 1 + HatType_FEZ HatType = 2 +) + +var HatType_name = map[int32]string{ + 1: "FEDORA", + 2: "FEZ", +} +var HatType_value = map[string]int32{ + "FEDORA": 1, + "FEZ": 2, +} + +func (x HatType) Enum() *HatType { + p := new(HatType) + *p = x + return p +} +func (x HatType) String() string { + return proto.EnumName(HatType_name, int32(x)) +} +func (x *HatType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(HatType_value, data, "HatType") + if err != nil { + return err + } + *x = HatType(value) + return nil +} + +// This enum represents days of the week. +type Days int32 + +const ( + Days_MONDAY Days = 1 + Days_TUESDAY Days = 2 + Days_LUNDI Days = 1 +) + +var Days_name = map[int32]string{ + 1: "MONDAY", + 2: "TUESDAY", + // Duplicate value: 1: "LUNDI", +} +var Days_value = map[string]int32{ + "MONDAY": 1, + "TUESDAY": 2, + "LUNDI": 1, +} + +func (x Days) Enum() *Days { + p := new(Days) + *p = x + return p +} +func (x Days) String() string { + return proto.EnumName(Days_name, int32(x)) +} +func (x *Days) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Days_value, data, "Days") + if err != nil { + return err + } + *x = Days(value) + return nil +} + +type Request_Color int32 + +const ( + Request_RED Request_Color = 0 + Request_GREEN Request_Color = 1 + Request_BLUE Request_Color = 2 +) + +var Request_Color_name = map[int32]string{ + 0: "RED", + 1: "GREEN", + 2: "BLUE", +} +var Request_Color_value = map[string]int32{ + "RED": 0, + "GREEN": 1, + "BLUE": 2, +} + +func (x Request_Color) Enum() *Request_Color { + p := new(Request_Color) + *p = x + return p +} +func (x Request_Color) String() string { + return proto.EnumName(Request_Color_name, int32(x)) +} +func (x *Request_Color) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Request_Color_value, data, "Request_Color") + if err != nil { + return err + } + *x = Request_Color(value) + return nil +} + +type Reply_Entry_Game int32 + +const ( + Reply_Entry_FOOTBALL Reply_Entry_Game = 1 + Reply_Entry_TENNIS Reply_Entry_Game = 2 +) + +var Reply_Entry_Game_name = map[int32]string{ + 1: "FOOTBALL", + 2: "TENNIS", +} +var Reply_Entry_Game_value = map[string]int32{ + "FOOTBALL": 1, + "TENNIS": 2, +} + +func (x Reply_Entry_Game) Enum() *Reply_Entry_Game { + p := new(Reply_Entry_Game) + *p = x + return p +} +func (x Reply_Entry_Game) String() string { + return proto.EnumName(Reply_Entry_Game_name, int32(x)) +} +func (x *Reply_Entry_Game) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Reply_Entry_Game_value, data, "Reply_Entry_Game") + if err != nil { + return err + } + *x = Reply_Entry_Game(value) + return nil +} + +// This is a message that might be sent somewhere. +type Request struct { + Key []int64 `protobuf:"varint,1,rep,name=key" json:"key,omitempty"` + // optional imp.ImportedMessage imported_message = 2; + Hue *Request_Color `protobuf:"varint,3,opt,name=hue,enum=my.test.Request_Color" json:"hue,omitempty"` + Hat *HatType `protobuf:"varint,4,opt,name=hat,enum=my.test.HatType,def=1" json:"hat,omitempty"` + // optional imp.ImportedMessage.Owner owner = 6; + Deadline *float32 `protobuf:"fixed32,7,opt,name=deadline,def=inf" json:"deadline,omitempty"` + Somegroup *Request_SomeGroup `protobuf:"group,8,opt,name=SomeGroup" json:"somegroup,omitempty"` + // This is a map field. It will generate map[int32]string. + NameMapping map[int32]string `protobuf:"bytes,14,rep,name=name_mapping" json:"name_mapping,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // This is a map field whose value type is a message. + MsgMapping map[int64]*Reply `protobuf:"bytes,15,rep,name=msg_mapping" json:"msg_mapping,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Reset_ *int32 `protobuf:"varint,12,opt,name=reset" json:"reset,omitempty"` + // This field should not conflict with any getters. + GetKey_ *string `protobuf:"bytes,16,opt,name=get_key" json:"get_key,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Request) Reset() { *m = Request{} } +func (m *Request) String() string { return proto.CompactTextString(m) } +func (*Request) ProtoMessage() {} + +const Default_Request_Hat HatType = HatType_FEDORA + +var Default_Request_Deadline float32 = float32(math.Inf(1)) + +func (m *Request) GetKey() []int64 { + if m != nil { + return m.Key + } + return nil +} + +func (m *Request) GetHue() Request_Color { + if m != nil && m.Hue != nil { + return *m.Hue + } + return Request_RED +} + +func (m *Request) GetHat() HatType { + if m != nil && m.Hat != nil { + return *m.Hat + } + return Default_Request_Hat +} + +func (m *Request) GetDeadline() float32 { + if m != nil && m.Deadline != nil { + return *m.Deadline + } + return Default_Request_Deadline +} + +func (m *Request) GetSomegroup() *Request_SomeGroup { + if m != nil { + return m.Somegroup + } + return nil +} + +func (m *Request) GetNameMapping() map[int32]string { + if m != nil { + return m.NameMapping + } + return nil +} + +func (m *Request) GetMsgMapping() map[int64]*Reply { + if m != nil { + return m.MsgMapping + } + return nil +} + +func (m *Request) GetReset_() int32 { + if m != nil && m.Reset_ != nil { + return *m.Reset_ + } + return 0 +} + +func (m *Request) GetGetKey_() string { + if m != nil && m.GetKey_ != nil { + return *m.GetKey_ + } + return "" +} + +type Request_SomeGroup struct { + GroupField *int32 `protobuf:"varint,9,opt,name=group_field" json:"group_field,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Request_SomeGroup) Reset() { *m = Request_SomeGroup{} } +func (m *Request_SomeGroup) String() string { return proto.CompactTextString(m) } +func (*Request_SomeGroup) ProtoMessage() {} + +func (m *Request_SomeGroup) GetGroupField() int32 { + if m != nil && m.GroupField != nil { + return *m.GroupField + } + return 0 +} + +type Reply struct { + Found []*Reply_Entry `protobuf:"bytes,1,rep,name=found" json:"found,omitempty"` + CompactKeys []int32 `protobuf:"varint,2,rep,packed,name=compact_keys" json:"compact_keys,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Reply) Reset() { *m = Reply{} } +func (m *Reply) String() string { return proto.CompactTextString(m) } +func (*Reply) ProtoMessage() {} + +var extRange_Reply = []proto.ExtensionRange{ + {100, 536870911}, +} + +func (*Reply) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_Reply +} +func (m *Reply) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +func (m *Reply) GetFound() []*Reply_Entry { + if m != nil { + return m.Found + } + return nil +} + +func (m *Reply) GetCompactKeys() []int32 { + if m != nil { + return m.CompactKeys + } + return nil +} + +type Reply_Entry struct { + KeyThatNeeds_1234Camel_CasIng *int64 `protobuf:"varint,1,req,name=key_that_needs_1234camel_CasIng" json:"key_that_needs_1234camel_CasIng,omitempty"` + Value *int64 `protobuf:"varint,2,opt,name=value,def=7" json:"value,omitempty"` + XMyFieldName_2 *int64 `protobuf:"varint,3,opt,name=_my_field_name_2" json:"_my_field_name_2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Reply_Entry) Reset() { *m = Reply_Entry{} } +func (m *Reply_Entry) String() string { return proto.CompactTextString(m) } +func (*Reply_Entry) ProtoMessage() {} + +const Default_Reply_Entry_Value int64 = 7 + +func (m *Reply_Entry) GetKeyThatNeeds_1234Camel_CasIng() int64 { + if m != nil && m.KeyThatNeeds_1234Camel_CasIng != nil { + return *m.KeyThatNeeds_1234Camel_CasIng + } + return 0 +} + +func (m *Reply_Entry) GetValue() int64 { + if m != nil && m.Value != nil { + return *m.Value + } + return Default_Reply_Entry_Value +} + +func (m *Reply_Entry) GetXMyFieldName_2() int64 { + if m != nil && m.XMyFieldName_2 != nil { + return *m.XMyFieldName_2 + } + return 0 +} + +type OtherBase struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OtherBase) Reset() { *m = OtherBase{} } +func (m *OtherBase) String() string { return proto.CompactTextString(m) } +func (*OtherBase) ProtoMessage() {} + +var extRange_OtherBase = []proto.ExtensionRange{ + {100, 536870911}, +} + +func (*OtherBase) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_OtherBase +} +func (m *OtherBase) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +func (m *OtherBase) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +type ReplyExtensions struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *ReplyExtensions) Reset() { *m = ReplyExtensions{} } +func (m *ReplyExtensions) String() string { return proto.CompactTextString(m) } +func (*ReplyExtensions) ProtoMessage() {} + +var E_ReplyExtensions_Time = &proto.ExtensionDesc{ + ExtendedType: (*Reply)(nil), + ExtensionType: (*float64)(nil), + Field: 101, + Name: "my.test.ReplyExtensions.time", + Tag: "fixed64,101,opt,name=time", +} + +var E_ReplyExtensions_Carrot = &proto.ExtensionDesc{ + ExtendedType: (*Reply)(nil), + ExtensionType: (*ReplyExtensions)(nil), + Field: 105, + Name: "my.test.ReplyExtensions.carrot", + Tag: "bytes,105,opt,name=carrot", +} + +var E_ReplyExtensions_Donut = &proto.ExtensionDesc{ + ExtendedType: (*OtherBase)(nil), + ExtensionType: (*ReplyExtensions)(nil), + Field: 101, + Name: "my.test.ReplyExtensions.donut", + Tag: "bytes,101,opt,name=donut", +} + +type OtherReplyExtensions struct { + Key *int32 `protobuf:"varint,1,opt,name=key" json:"key,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OtherReplyExtensions) Reset() { *m = OtherReplyExtensions{} } +func (m *OtherReplyExtensions) String() string { return proto.CompactTextString(m) } +func (*OtherReplyExtensions) ProtoMessage() {} + +func (m *OtherReplyExtensions) GetKey() int32 { + if m != nil && m.Key != nil { + return *m.Key + } + return 0 +} + +type OldReply struct { + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OldReply) Reset() { *m = OldReply{} } +func (m *OldReply) String() string { return proto.CompactTextString(m) } +func (*OldReply) ProtoMessage() {} + +func (m *OldReply) Marshal() ([]byte, error) { + return proto.MarshalMessageSet(m.ExtensionMap()) +} +func (m *OldReply) Unmarshal(buf []byte) error { + return proto.UnmarshalMessageSet(buf, m.ExtensionMap()) +} +func (m *OldReply) MarshalJSON() ([]byte, error) { + return proto.MarshalMessageSetJSON(m.XXX_extensions) +} +func (m *OldReply) UnmarshalJSON(buf []byte) error { + return proto.UnmarshalMessageSetJSON(buf, m.XXX_extensions) +} + +// ensure OldReply satisfies proto.Marshaler and proto.Unmarshaler +var _ proto.Marshaler = (*OldReply)(nil) +var _ proto.Unmarshaler = (*OldReply)(nil) + +var extRange_OldReply = []proto.ExtensionRange{ + {100, 2147483646}, +} + +func (*OldReply) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_OldReply +} +func (m *OldReply) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type Communique struct { + MakeMeCry *bool `protobuf:"varint,1,opt,name=make_me_cry" json:"make_me_cry,omitempty"` + // This is a oneof, called "union". + // + // Types that are valid to be assigned to Union: + // *Communique_Number + // *Communique_Name + // *Communique_Data + // *Communique_TempC + // *Communique_Height + // *Communique_Today + // *Communique_Maybe + // *Communique_Delta_ + // *Communique_Msg + // *Communique_Somegroup + Union isCommunique_Union `protobuf_oneof:"union"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Communique) Reset() { *m = Communique{} } +func (m *Communique) String() string { return proto.CompactTextString(m) } +func (*Communique) ProtoMessage() {} + +type isCommunique_Union interface { + isCommunique_Union() +} + +type Communique_Number struct { + Number int32 `protobuf:"varint,5,opt,name=number,oneof"` +} +type Communique_Name struct { + Name string `protobuf:"bytes,6,opt,name=name,oneof"` +} +type Communique_Data struct { + Data []byte `protobuf:"bytes,7,opt,name=data,oneof"` +} +type Communique_TempC struct { + TempC float64 `protobuf:"fixed64,8,opt,name=temp_c,oneof"` +} +type Communique_Height struct { + Height float32 `protobuf:"fixed32,9,opt,name=height,oneof"` +} +type Communique_Today struct { + Today Days `protobuf:"varint,10,opt,name=today,enum=my.test.Days,oneof"` +} +type Communique_Maybe struct { + Maybe bool `protobuf:"varint,11,opt,name=maybe,oneof"` +} +type Communique_Delta_ struct { + Delta int32 `protobuf:"zigzag32,12,opt,name=delta,oneof"` +} +type Communique_Msg struct { + Msg *Reply `protobuf:"bytes,13,opt,name=msg,oneof"` +} +type Communique_Somegroup struct { + Somegroup *Communique_SomeGroup `protobuf:"group,14,opt,name=SomeGroup,oneof"` +} + +func (*Communique_Number) isCommunique_Union() {} +func (*Communique_Name) isCommunique_Union() {} +func (*Communique_Data) isCommunique_Union() {} +func (*Communique_TempC) isCommunique_Union() {} +func (*Communique_Height) isCommunique_Union() {} +func (*Communique_Today) isCommunique_Union() {} +func (*Communique_Maybe) isCommunique_Union() {} +func (*Communique_Delta_) isCommunique_Union() {} +func (*Communique_Msg) isCommunique_Union() {} +func (*Communique_Somegroup) isCommunique_Union() {} + +func (m *Communique) GetUnion() isCommunique_Union { + if m != nil { + return m.Union + } + return nil +} + +func (m *Communique) GetMakeMeCry() bool { + if m != nil && m.MakeMeCry != nil { + return *m.MakeMeCry + } + return false +} + +func (m *Communique) GetNumber() int32 { + if x, ok := m.GetUnion().(*Communique_Number); ok { + return x.Number + } + return 0 +} + +func (m *Communique) GetName() string { + if x, ok := m.GetUnion().(*Communique_Name); ok { + return x.Name + } + return "" +} + +func (m *Communique) GetData() []byte { + if x, ok := m.GetUnion().(*Communique_Data); ok { + return x.Data + } + return nil +} + +func (m *Communique) GetTempC() float64 { + if x, ok := m.GetUnion().(*Communique_TempC); ok { + return x.TempC + } + return 0 +} + +func (m *Communique) GetHeight() float32 { + if x, ok := m.GetUnion().(*Communique_Height); ok { + return x.Height + } + return 0 +} + +func (m *Communique) GetToday() Days { + if x, ok := m.GetUnion().(*Communique_Today); ok { + return x.Today + } + return Days_MONDAY +} + +func (m *Communique) GetMaybe() bool { + if x, ok := m.GetUnion().(*Communique_Maybe); ok { + return x.Maybe + } + return false +} + +func (m *Communique) GetDelta() int32 { + if x, ok := m.GetUnion().(*Communique_Delta_); ok { + return x.Delta + } + return 0 +} + +func (m *Communique) GetMsg() *Reply { + if x, ok := m.GetUnion().(*Communique_Msg); ok { + return x.Msg + } + return nil +} + +func (m *Communique) GetSomegroup() *Communique_SomeGroup { + if x, ok := m.GetUnion().(*Communique_Somegroup); ok { + return x.Somegroup + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*Communique) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _Communique_OneofMarshaler, _Communique_OneofUnmarshaler, []interface{}{ + (*Communique_Number)(nil), + (*Communique_Name)(nil), + (*Communique_Data)(nil), + (*Communique_TempC)(nil), + (*Communique_Height)(nil), + (*Communique_Today)(nil), + (*Communique_Maybe)(nil), + (*Communique_Delta_)(nil), + (*Communique_Msg)(nil), + (*Communique_Somegroup)(nil), + } +} + +func _Communique_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*Communique) + // union + switch x := m.Union.(type) { + case *Communique_Number: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Number)) + case *Communique_Name: + _ = b.EncodeVarint(6<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Name) + case *Communique_Data: + _ = b.EncodeVarint(7<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Data) + case *Communique_TempC: + _ = b.EncodeVarint(8<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.TempC)) + case *Communique_Height: + _ = b.EncodeVarint(9<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Height))) + case *Communique_Today: + _ = b.EncodeVarint(10<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Today)) + case *Communique_Maybe: + t := uint64(0) + if x.Maybe { + t = 1 + } + _ = b.EncodeVarint(11<<3 | proto.WireVarint) + _ = b.EncodeVarint(t) + case *Communique_Delta_: + _ = b.EncodeVarint(12<<3 | proto.WireVarint) + _ = b.EncodeZigzag32(uint64(x.Delta)) + case *Communique_Msg: + _ = b.EncodeVarint(13<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.Msg); err != nil { + return err + } + case *Communique_Somegroup: + _ = b.EncodeVarint(14<<3 | proto.WireStartGroup) + if err := b.Marshal(x.Somegroup); err != nil { + return err + } + _ = b.EncodeVarint(14<<3 | proto.WireEndGroup) + case nil: + default: + return fmt.Errorf("Communique.Union has unexpected type %T", x) + } + return nil +} + +func _Communique_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*Communique) + switch tag { + case 5: // union.number + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Union = &Communique_Number{int32(x)} + return true, err + case 6: // union.name + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Union = &Communique_Name{x} + return true, err + case 7: // union.data + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.Union = &Communique_Data{x} + return true, err + case 8: // union.temp_c + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.Union = &Communique_TempC{math.Float64frombits(x)} + return true, err + case 9: // union.height + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.Union = &Communique_Height{math.Float32frombits(uint32(x))} + return true, err + case 10: // union.today + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Union = &Communique_Today{Days(x)} + return true, err + case 11: // union.maybe + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Union = &Communique_Maybe{x != 0} + return true, err + case 12: // union.delta + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag32() + m.Union = &Communique_Delta_{int32(x)} + return true, err + case 13: // union.msg + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Reply) + err := b.DecodeMessage(msg) + m.Union = &Communique_Msg{msg} + return true, err + case 14: // union.somegroup + if wire != proto.WireStartGroup { + return true, proto.ErrInternalBadWireType + } + msg := new(Communique_SomeGroup) + err := b.DecodeGroup(msg) + m.Union = &Communique_Somegroup{msg} + return true, err + default: + return false, nil + } +} + +type Communique_SomeGroup struct { + Member *string `protobuf:"bytes,15,opt,name=member" json:"member,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Communique_SomeGroup) Reset() { *m = Communique_SomeGroup{} } +func (m *Communique_SomeGroup) String() string { return proto.CompactTextString(m) } +func (*Communique_SomeGroup) ProtoMessage() {} + +func (m *Communique_SomeGroup) GetMember() string { + if m != nil && m.Member != nil { + return *m.Member + } + return "" +} + +type Communique_Delta struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *Communique_Delta) Reset() { *m = Communique_Delta{} } +func (m *Communique_Delta) String() string { return proto.CompactTextString(m) } +func (*Communique_Delta) ProtoMessage() {} + +var E_Tag = &proto.ExtensionDesc{ + ExtendedType: (*Reply)(nil), + ExtensionType: (*string)(nil), + Field: 103, + Name: "my.test.tag", + Tag: "bytes,103,opt,name=tag", +} + +var E_Donut = &proto.ExtensionDesc{ + ExtendedType: (*Reply)(nil), + ExtensionType: (*OtherReplyExtensions)(nil), + Field: 106, + Name: "my.test.donut", + Tag: "bytes,106,opt,name=donut", +} + +func init() { + proto.RegisterEnum("my.test.HatType", HatType_name, HatType_value) + proto.RegisterEnum("my.test.Days", Days_name, Days_value) + proto.RegisterEnum("my.test.Request_Color", Request_Color_name, Request_Color_value) + proto.RegisterEnum("my.test.Reply_Entry_Game", Reply_Entry_Game_name, Reply_Entry_Game_value) + proto.RegisterExtension(E_ReplyExtensions_Time) + proto.RegisterExtension(E_ReplyExtensions_Carrot) + proto.RegisterExtension(E_ReplyExtensions_Donut) + proto.RegisterExtension(E_Tag) + proto.RegisterExtension(E_Donut) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/my_test/test.pb.go.golden b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/my_test/test.pb.go.golden new file mode 100644 index 0000000000000000000000000000000000000000..8561259fd629d1debb02d1beb08938530eaf50af --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/my_test/test.pb.go.golden @@ -0,0 +1,822 @@ +// Code generated by protoc-gen-gogo. +// source: my_test/test.proto +// DO NOT EDIT! + +/* +Package my_test is a generated protocol buffer package. + +This package holds interesting messages. + +It is generated from these files: + my_test/test.proto + +It has these top-level messages: + Request + Reply + OtherBase + ReplyExtensions + OtherReplyExtensions + OldReply + Communique +*/ +package my_test + +import proto "github.com/gogo/protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import multitest2 "multi" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type HatType int32 + +const ( + // deliberately skipping 0 + HatType_FEDORA HatType = 1 + HatType_FEZ HatType = 2 +) + +var HatType_name = map[int32]string{ + 1: "FEDORA", + 2: "FEZ", +} +var HatType_value = map[string]int32{ + "FEDORA": 1, + "FEZ": 2, +} + +func (x HatType) Enum() *HatType { + p := new(HatType) + *p = x + return p +} +func (x HatType) String() string { + return proto.EnumName(HatType_name, int32(x)) +} +func (x *HatType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(HatType_value, data, "HatType") + if err != nil { + return err + } + *x = HatType(value) + return nil +} + +// This enum represents days of the week. +type Days int32 + +const ( + Days_MONDAY Days = 1 + Days_TUESDAY Days = 2 + Days_LUNDI Days = 1 +) + +var Days_name = map[int32]string{ + 1: "MONDAY", + 2: "TUESDAY", + // Duplicate value: 1: "LUNDI", +} +var Days_value = map[string]int32{ + "MONDAY": 1, + "TUESDAY": 2, + "LUNDI": 1, +} + +func (x Days) Enum() *Days { + p := new(Days) + *p = x + return p +} +func (x Days) String() string { + return proto.EnumName(Days_name, int32(x)) +} +func (x *Days) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Days_value, data, "Days") + if err != nil { + return err + } + *x = Days(value) + return nil +} + +type Request_Color int32 + +const ( + Request_RED Request_Color = 0 + Request_GREEN Request_Color = 1 + Request_BLUE Request_Color = 2 +) + +var Request_Color_name = map[int32]string{ + 0: "RED", + 1: "GREEN", + 2: "BLUE", +} +var Request_Color_value = map[string]int32{ + "RED": 0, + "GREEN": 1, + "BLUE": 2, +} + +func (x Request_Color) Enum() *Request_Color { + p := new(Request_Color) + *p = x + return p +} +func (x Request_Color) String() string { + return proto.EnumName(Request_Color_name, int32(x)) +} +func (x *Request_Color) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Request_Color_value, data, "Request_Color") + if err != nil { + return err + } + *x = Request_Color(value) + return nil +} + +type Reply_Entry_Game int32 + +const ( + Reply_Entry_FOOTBALL Reply_Entry_Game = 1 + Reply_Entry_TENNIS Reply_Entry_Game = 2 +) + +var Reply_Entry_Game_name = map[int32]string{ + 1: "FOOTBALL", + 2: "TENNIS", +} +var Reply_Entry_Game_value = map[string]int32{ + "FOOTBALL": 1, + "TENNIS": 2, +} + +func (x Reply_Entry_Game) Enum() *Reply_Entry_Game { + p := new(Reply_Entry_Game) + *p = x + return p +} +func (x Reply_Entry_Game) String() string { + return proto.EnumName(Reply_Entry_Game_name, int32(x)) +} +func (x *Reply_Entry_Game) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Reply_Entry_Game_value, data, "Reply_Entry_Game") + if err != nil { + return err + } + *x = Reply_Entry_Game(value) + return nil +} + +// This is a message that might be sent somewhere. +type Request struct { + Key []int64 `protobuf:"varint,1,rep,name=key" json:"key,omitempty"` + // optional imp.ImportedMessage imported_message = 2; + Hue *Request_Color `protobuf:"varint,3,opt,name=hue,enum=my.test.Request_Color" json:"hue,omitempty"` + Hat *HatType `protobuf:"varint,4,opt,name=hat,enum=my.test.HatType,def=1" json:"hat,omitempty"` + // optional imp.ImportedMessage.Owner owner = 6; + Deadline *float32 `protobuf:"fixed32,7,opt,name=deadline,def=inf" json:"deadline,omitempty"` + Somegroup *Request_SomeGroup `protobuf:"group,8,opt,name=SomeGroup" json:"somegroup,omitempty"` + // This is a map field. It will generate map[int32]string. + NameMapping map[int32]string `protobuf:"bytes,14,rep,name=name_mapping" json:"name_mapping,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // This is a map field whose value type is a message. + MsgMapping map[int64]*Reply `protobuf:"bytes,15,rep,name=msg_mapping" json:"msg_mapping,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Reset_ *int32 `protobuf:"varint,12,opt,name=reset" json:"reset,omitempty"` + // This field should not conflict with any getters. + GetKey_ *string `protobuf:"bytes,16,opt,name=get_key" json:"get_key,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Request) Reset() { *m = Request{} } +func (m *Request) String() string { return proto.CompactTextString(m) } +func (*Request) ProtoMessage() {} + +const Default_Request_Hat HatType = HatType_FEDORA + +var Default_Request_Deadline float32 = float32(math.Inf(1)) + +func (m *Request) GetKey() []int64 { + if m != nil { + return m.Key + } + return nil +} + +func (m *Request) GetHue() Request_Color { + if m != nil && m.Hue != nil { + return *m.Hue + } + return Request_RED +} + +func (m *Request) GetHat() HatType { + if m != nil && m.Hat != nil { + return *m.Hat + } + return Default_Request_Hat +} + +func (m *Request) GetDeadline() float32 { + if m != nil && m.Deadline != nil { + return *m.Deadline + } + return Default_Request_Deadline +} + +func (m *Request) GetSomegroup() *Request_SomeGroup { + if m != nil { + return m.Somegroup + } + return nil +} + +func (m *Request) GetNameMapping() map[int32]string { + if m != nil { + return m.NameMapping + } + return nil +} + +func (m *Request) GetMsgMapping() map[int64]*Reply { + if m != nil { + return m.MsgMapping + } + return nil +} + +func (m *Request) GetReset_() int32 { + if m != nil && m.Reset_ != nil { + return *m.Reset_ + } + return 0 +} + +func (m *Request) GetGetKey_() string { + if m != nil && m.GetKey_ != nil { + return *m.GetKey_ + } + return "" +} + +type Request_SomeGroup struct { + GroupField *int32 `protobuf:"varint,9,opt,name=group_field" json:"group_field,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Request_SomeGroup) Reset() { *m = Request_SomeGroup{} } +func (m *Request_SomeGroup) String() string { return proto.CompactTextString(m) } +func (*Request_SomeGroup) ProtoMessage() {} + +func (m *Request_SomeGroup) GetGroupField() int32 { + if m != nil && m.GroupField != nil { + return *m.GroupField + } + return 0 +} + +type Reply struct { + Found []*Reply_Entry `protobuf:"bytes,1,rep,name=found" json:"found,omitempty"` + CompactKeys []int32 `protobuf:"varint,2,rep,packed,name=compact_keys" json:"compact_keys,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Reply) Reset() { *m = Reply{} } +func (m *Reply) String() string { return proto.CompactTextString(m) } +func (*Reply) ProtoMessage() {} + +var extRange_Reply = []proto.ExtensionRange{ + {100, 536870911}, +} + +func (*Reply) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_Reply +} +func (m *Reply) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +func (m *Reply) GetFound() []*Reply_Entry { + if m != nil { + return m.Found + } + return nil +} + +func (m *Reply) GetCompactKeys() []int32 { + if m != nil { + return m.CompactKeys + } + return nil +} + +type Reply_Entry struct { + KeyThatNeeds_1234Camel_CasIng *int64 `protobuf:"varint,1,req,name=key_that_needs_1234camel_CasIng" json:"key_that_needs_1234camel_CasIng,omitempty"` + Value *int64 `protobuf:"varint,2,opt,name=value,def=7" json:"value,omitempty"` + XMyFieldName_2 *int64 `protobuf:"varint,3,opt,name=_my_field_name_2" json:"_my_field_name_2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Reply_Entry) Reset() { *m = Reply_Entry{} } +func (m *Reply_Entry) String() string { return proto.CompactTextString(m) } +func (*Reply_Entry) ProtoMessage() {} + +const Default_Reply_Entry_Value int64 = 7 + +func (m *Reply_Entry) GetKeyThatNeeds_1234Camel_CasIng() int64 { + if m != nil && m.KeyThatNeeds_1234Camel_CasIng != nil { + return *m.KeyThatNeeds_1234Camel_CasIng + } + return 0 +} + +func (m *Reply_Entry) GetValue() int64 { + if m != nil && m.Value != nil { + return *m.Value + } + return Default_Reply_Entry_Value +} + +func (m *Reply_Entry) GetXMyFieldName_2() int64 { + if m != nil && m.XMyFieldName_2 != nil { + return *m.XMyFieldName_2 + } + return 0 +} + +type OtherBase struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OtherBase) Reset() { *m = OtherBase{} } +func (m *OtherBase) String() string { return proto.CompactTextString(m) } +func (*OtherBase) ProtoMessage() {} + +var extRange_OtherBase = []proto.ExtensionRange{ + {100, 536870911}, +} + +func (*OtherBase) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_OtherBase +} +func (m *OtherBase) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +func (m *OtherBase) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +type ReplyExtensions struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *ReplyExtensions) Reset() { *m = ReplyExtensions{} } +func (m *ReplyExtensions) String() string { return proto.CompactTextString(m) } +func (*ReplyExtensions) ProtoMessage() {} + +var E_ReplyExtensions_Time = &proto.ExtensionDesc{ + ExtendedType: (*Reply)(nil), + ExtensionType: (*float64)(nil), + Field: 101, + Name: "my.test.ReplyExtensions.time", + Tag: "fixed64,101,opt,name=time", +} + +var E_ReplyExtensions_Carrot = &proto.ExtensionDesc{ + ExtendedType: (*Reply)(nil), + ExtensionType: (*ReplyExtensions)(nil), + Field: 105, + Name: "my.test.ReplyExtensions.carrot", + Tag: "bytes,105,opt,name=carrot", +} + +var E_ReplyExtensions_Donut = &proto.ExtensionDesc{ + ExtendedType: (*OtherBase)(nil), + ExtensionType: (*ReplyExtensions)(nil), + Field: 101, + Name: "my.test.ReplyExtensions.donut", + Tag: "bytes,101,opt,name=donut", +} + +type OtherReplyExtensions struct { + Key *int32 `protobuf:"varint,1,opt,name=key" json:"key,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OtherReplyExtensions) Reset() { *m = OtherReplyExtensions{} } +func (m *OtherReplyExtensions) String() string { return proto.CompactTextString(m) } +func (*OtherReplyExtensions) ProtoMessage() {} + +func (m *OtherReplyExtensions) GetKey() int32 { + if m != nil && m.Key != nil { + return *m.Key + } + return 0 +} + +type OldReply struct { + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OldReply) Reset() { *m = OldReply{} } +func (m *OldReply) String() string { return proto.CompactTextString(m) } +func (*OldReply) ProtoMessage() {} + +func (m *OldReply) Marshal() ([]byte, error) { + return proto.MarshalMessageSet(m.ExtensionMap()) +} +func (m *OldReply) Unmarshal(buf []byte) error { + return proto.UnmarshalMessageSet(buf, m.ExtensionMap()) +} +func (m *OldReply) MarshalJSON() ([]byte, error) { + return proto.MarshalMessageSetJSON(m.XXX_extensions) +} +func (m *OldReply) UnmarshalJSON(buf []byte) error { + return proto.UnmarshalMessageSetJSON(buf, m.XXX_extensions) +} + +// ensure OldReply satisfies proto.Marshaler and proto.Unmarshaler +var _ proto.Marshaler = (*OldReply)(nil) +var _ proto.Unmarshaler = (*OldReply)(nil) + +var extRange_OldReply = []proto.ExtensionRange{ + {100, 2147483646}, +} + +func (*OldReply) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_OldReply +} +func (m *OldReply) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type Communique struct { + MakeMeCry *bool `protobuf:"varint,1,opt,name=make_me_cry" json:"make_me_cry,omitempty"` + // This is a oneof, called "union". + // + // Types that are valid to be assigned to Union: + // *Communique_Number + // *Communique_Name + // *Communique_Data + // *Communique_TempC + // *Communique_Height + // *Communique_Today + // *Communique_Maybe + // *Communique_Delta_ + // *Communique_Msg + // *Communique_Somegroup + Union isCommunique_Union `protobuf_oneof:"union"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Communique) Reset() { *m = Communique{} } +func (m *Communique) String() string { return proto.CompactTextString(m) } +func (*Communique) ProtoMessage() {} + +type isCommunique_Union interface { + isCommunique_Union() +} + +type Communique_Number struct { + Number int32 `protobuf:"varint,5,opt,name=number,oneof"` +} +type Communique_Name struct { + Name string `protobuf:"bytes,6,opt,name=name,oneof"` +} +type Communique_Data struct { + Data []byte `protobuf:"bytes,7,opt,name=data,oneof"` +} +type Communique_TempC struct { + TempC float64 `protobuf:"fixed64,8,opt,name=temp_c,oneof"` +} +type Communique_Height struct { + Height float32 `protobuf:"fixed32,9,opt,name=height,oneof"` +} +type Communique_Today struct { + Today Days `protobuf:"varint,10,opt,name=today,enum=my.test.Days,oneof"` +} +type Communique_Maybe struct { + Maybe bool `protobuf:"varint,11,opt,name=maybe,oneof"` +} +type Communique_Delta_ struct { + Delta int32 `protobuf:"zigzag32,12,opt,name=delta,oneof"` +} +type Communique_Msg struct { + Msg *Reply `protobuf:"bytes,13,opt,name=msg,oneof"` +} +type Communique_Somegroup struct { + Somegroup *Communique_SomeGroup `protobuf:"group,14,opt,name=SomeGroup,oneof"` +} + +func (*Communique_Number) isCommunique_Union() {} +func (*Communique_Name) isCommunique_Union() {} +func (*Communique_Data) isCommunique_Union() {} +func (*Communique_TempC) isCommunique_Union() {} +func (*Communique_Height) isCommunique_Union() {} +func (*Communique_Today) isCommunique_Union() {} +func (*Communique_Maybe) isCommunique_Union() {} +func (*Communique_Delta_) isCommunique_Union() {} +func (*Communique_Msg) isCommunique_Union() {} +func (*Communique_Somegroup) isCommunique_Union() {} + +func (m *Communique) GetUnion() isCommunique_Union { + if m != nil { + return m.Union + } + return nil +} + +func (m *Communique) GetMakeMeCry() bool { + if m != nil && m.MakeMeCry != nil { + return *m.MakeMeCry + } + return false +} + +func (m *Communique) GetNumber() int32 { + if x, ok := m.GetUnion().(*Communique_Number); ok { + return x.Number + } + return 0 +} + +func (m *Communique) GetName() string { + if x, ok := m.GetUnion().(*Communique_Name); ok { + return x.Name + } + return "" +} + +func (m *Communique) GetData() []byte { + if x, ok := m.GetUnion().(*Communique_Data); ok { + return x.Data + } + return nil +} + +func (m *Communique) GetTempC() float64 { + if x, ok := m.GetUnion().(*Communique_TempC); ok { + return x.TempC + } + return 0 +} + +func (m *Communique) GetHeight() float32 { + if x, ok := m.GetUnion().(*Communique_Height); ok { + return x.Height + } + return 0 +} + +func (m *Communique) GetToday() Days { + if x, ok := m.GetUnion().(*Communique_Today); ok { + return x.Today + } + return Days_MONDAY +} + +func (m *Communique) GetMaybe() bool { + if x, ok := m.GetUnion().(*Communique_Maybe); ok { + return x.Maybe + } + return false +} + +func (m *Communique) GetDelta() int32 { + if x, ok := m.GetUnion().(*Communique_Delta_); ok { + return x.Delta + } + return 0 +} + +func (m *Communique) GetMsg() *Reply { + if x, ok := m.GetUnion().(*Communique_Msg); ok { + return x.Msg + } + return nil +} + +func (m *Communique) GetSomegroup() *Communique_SomeGroup { + if x, ok := m.GetUnion().(*Communique_Somegroup); ok { + return x.Somegroup + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*Communique) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _Communique_OneofMarshaler, _Communique_OneofUnmarshaler, []interface{}{ + (*Communique_Number)(nil), + (*Communique_Name)(nil), + (*Communique_Data)(nil), + (*Communique_TempC)(nil), + (*Communique_Height)(nil), + (*Communique_Today)(nil), + (*Communique_Maybe)(nil), + (*Communique_Delta_)(nil), + (*Communique_Msg)(nil), + (*Communique_Somegroup)(nil), + } +} + +func _Communique_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*Communique) + // union + switch x := m.Union.(type) { + case *Communique_Number: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Number)) + case *Communique_Name: + _ = b.EncodeVarint(6<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Name) + case *Communique_Data: + _ = b.EncodeVarint(7<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Data) + case *Communique_TempC: + _ = b.EncodeVarint(8<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.TempC)) + case *Communique_Height: + _ = b.EncodeVarint(9<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Height))) + case *Communique_Today: + _ = b.EncodeVarint(10<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Today)) + case *Communique_Maybe: + t := uint64(0) + if x.Maybe { + t = 1 + } + _ = b.EncodeVarint(11<<3 | proto.WireVarint) + _ = b.EncodeVarint(t) + case *Communique_Delta_: + _ = b.EncodeVarint(12<<3 | proto.WireVarint) + _ = b.EncodeZigzag32(uint64(x.Delta)) + case *Communique_Msg: + _ = b.EncodeVarint(13<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.Msg); err != nil { + return err + } + case *Communique_Somegroup: + _ = b.EncodeVarint(14<<3 | proto.WireStartGroup) + if err := b.Marshal(x.Somegroup); err != nil { + return err + } + _ = b.EncodeVarint(14<<3 | proto.WireEndGroup) + case nil: + default: + return fmt.Errorf("Communique.Union has unexpected type %T", x) + } + return nil +} + +func _Communique_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*Communique) + switch tag { + case 5: // union.number + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Union = &Communique_Number{int32(x)} + return true, err + case 6: // union.name + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Union = &Communique_Name{x} + return true, err + case 7: // union.data + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.Union = &Communique_Data{x} + return true, err + case 8: // union.temp_c + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.Union = &Communique_TempC{math.Float64frombits(x)} + return true, err + case 9: // union.height + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.Union = &Communique_Height{math.Float32frombits(uint32(x))} + return true, err + case 10: // union.today + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Union = &Communique_Today{Days(x)} + return true, err + case 11: // union.maybe + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Union = &Communique_Maybe{x != 0} + return true, err + case 12: // union.delta + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag32() + m.Union = &Communique_Delta_{int32(x)} + return true, err + case 13: // union.msg + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Reply) + err := b.DecodeMessage(msg) + m.Union = &Communique_Msg{msg} + return true, err + case 14: // union.somegroup + if wire != proto.WireStartGroup { + return true, proto.ErrInternalBadWireType + } + msg := new(Communique_SomeGroup) + err := b.DecodeGroup(msg) + m.Union = &Communique_Somegroup{msg} + return true, err + default: + return false, nil + } +} + +type Communique_SomeGroup struct { + Member *string `protobuf:"bytes,15,opt,name=member" json:"member,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Communique_SomeGroup) Reset() { *m = Communique_SomeGroup{} } +func (m *Communique_SomeGroup) String() string { return proto.CompactTextString(m) } +func (*Communique_SomeGroup) ProtoMessage() {} + +func (m *Communique_SomeGroup) GetMember() string { + if m != nil && m.Member != nil { + return *m.Member + } + return "" +} + +type Communique_Delta struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *Communique_Delta) Reset() { *m = Communique_Delta{} } +func (m *Communique_Delta) String() string { return proto.CompactTextString(m) } +func (*Communique_Delta) ProtoMessage() {} + +var E_Tag = &proto.ExtensionDesc{ + ExtendedType: (*Reply)(nil), + ExtensionType: (*string)(nil), + Field: 103, + Name: "my.test.tag", + Tag: "bytes,103,opt,name=tag", +} + +var E_Donut = &proto.ExtensionDesc{ + ExtendedType: (*Reply)(nil), + ExtensionType: (*OtherReplyExtensions)(nil), + Field: 106, + Name: "my.test.donut", + Tag: "bytes,106,opt,name=donut", +} + +func init() { + proto.RegisterEnum("my.test.HatType", HatType_name, HatType_value) + proto.RegisterEnum("my.test.Days", Days_name, Days_value) + proto.RegisterEnum("my.test.Request_Color", Request_Color_name, Request_Color_value) + proto.RegisterEnum("my.test.Reply_Entry_Game", Reply_Entry_Game_name, Reply_Entry_Game_value) + proto.RegisterExtension(E_ReplyExtensions_Time) + proto.RegisterExtension(E_ReplyExtensions_Carrot) + proto.RegisterExtension(E_ReplyExtensions_Donut) + proto.RegisterExtension(E_Tag) + proto.RegisterExtension(E_Donut) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/my_test/test.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/my_test/test.proto new file mode 100644 index 0000000000000000000000000000000000000000..8e7094632de1ed15ffdac8e907151a7d154f4d6f --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/my_test/test.proto @@ -0,0 +1,156 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 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"; + +// This package holds interesting messages. +package my.test; // dotted package name + +//import "imp.proto"; +import "multi/multi1.proto"; // unused import + +enum HatType { + // deliberately skipping 0 + FEDORA = 1; + FEZ = 2; +} + +// This enum represents days of the week. +enum Days { + option allow_alias = true; + + MONDAY = 1; + TUESDAY = 2; + LUNDI = 1; // same value as MONDAY +} + +// This is a message that might be sent somewhere. +message Request { + enum Color { + RED = 0; + GREEN = 1; + BLUE = 2; + } + repeated int64 key = 1; +// optional imp.ImportedMessage imported_message = 2; + optional Color hue = 3; // no default + optional HatType hat = 4 [default=FEDORA]; +// optional imp.ImportedMessage.Owner owner = 6; + optional float deadline = 7 [default=inf]; + optional group SomeGroup = 8 { + optional int32 group_field = 9; + } + + // These foreign types are in imp2.proto, + // which is publicly imported by imp.proto. +// optional imp.PubliclyImportedMessage pub = 10; +// optional imp.PubliclyImportedEnum pub_enum = 13 [default=HAIR]; + + + // This is a map field. It will generate map[int32]string. + map name_mapping = 14; + // This is a map field whose value type is a message. + map msg_mapping = 15; + + optional int32 reset = 12; + // This field should not conflict with any getters. + optional string get_key = 16; +} + +message Reply { + message Entry { + required int64 key_that_needs_1234camel_CasIng = 1; + optional int64 value = 2 [default=7]; + optional int64 _my_field_name_2 = 3; + enum Game { + FOOTBALL = 1; + TENNIS = 2; + } + } + repeated Entry found = 1; + repeated int32 compact_keys = 2 [packed=true]; + extensions 100 to max; +} + +message OtherBase { + optional string name = 1; + extensions 100 to max; +} + +message ReplyExtensions { + extend Reply { + optional double time = 101; + optional ReplyExtensions carrot = 105; + } + extend OtherBase { + optional ReplyExtensions donut = 101; + } +} + +message OtherReplyExtensions { + optional int32 key = 1; +} + +// top-level extension +extend Reply { + optional string tag = 103; + optional OtherReplyExtensions donut = 106; +// optional imp.ImportedMessage elephant = 107; // extend with message from another file. +} + +message OldReply { + // Extensions will be encoded in MessageSet wire format. + option message_set_wire_format = true; + extensions 100 to max; +} + +message Communique { + optional bool make_me_cry = 1; + + // This is a oneof, called "union". + oneof union { + int32 number = 5; + string name = 6; + bytes data = 7; + double temp_c = 8; + float height = 9; + Days today = 10; + bool maybe = 11; + sint32 delta = 12; // name will conflict with Delta below + Reply msg = 13; + group SomeGroup = 14 { + optional string member = 15; + } + } + + message Delta {} +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/proto3.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/proto3.proto new file mode 100644 index 0000000000000000000000000000000000000000..c994914e497093d41f5f644d62ebaae9ca49d612 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/testdata/proto3.proto @@ -0,0 +1,52 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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 proto3; + +message Request { + enum Flavour { + SWEET = 0; + SOUR = 1; + UMAMI = 2; + GOPHERLICIOUS = 3; + } + string name = 1; + repeated int64 key = 2; + Flavour taste = 3; + Book book = 4; +} + +message Book { + string title = 1; + bytes raw_data = 2; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogofast/main.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogofast/main.go new file mode 100644 index 0000000000000000000000000000000000000000..f2fd588a7f063f8c3cd65c15ea1852772fe14e87 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogofast/main.go @@ -0,0 +1,47 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 main + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/command" +) + +func main() { + req := command.Read() + files := req.GetProtoFile() + files = vanity.FilterFiles(files, vanity.NotInPackageGoogleProtobuf) + + vanity.ForEachFile(files, vanity.TurnOnMarshalerAll) + vanity.ForEachFile(files, vanity.TurnOnSizerAll) + vanity.ForEachFile(files, vanity.TurnOnUnmarshalerAll) + + resp := command.Generate(req) + command.Write(resp) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogofaster/main.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogofaster/main.go new file mode 100644 index 0000000000000000000000000000000000000000..fd7cfcb5985993444c88de82dd23af236a5576ce --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogofaster/main.go @@ -0,0 +1,50 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 main + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/command" +) + +func main() { + req := command.Read() + files := req.GetProtoFile() + files = vanity.FilterFiles(files, vanity.NotInPackageGoogleProtobuf) + + vanity.ForEachFile(files, vanity.TurnOnMarshalerAll) + vanity.ForEachFile(files, vanity.TurnOnSizerAll) + vanity.ForEachFile(files, vanity.TurnOnUnmarshalerAll) + + vanity.ForEachFieldInFilesExcludingExtensions(vanity.OnlyProto2(files), vanity.TurnOffNullableForNativeTypesWithoutDefaultsOnly) + vanity.ForEachFile(files, vanity.TurnOffGoUnrecognizedAll) + + resp := command.Generate(req) + command.Write(resp) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogoslick/main.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogoslick/main.go new file mode 100644 index 0000000000000000000000000000000000000000..2f77ea4b32080afcb74d00e959ba0f40a20facfc --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogoslick/main.go @@ -0,0 +1,59 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 main + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/command" +) + +func main() { + req := command.Read() + files := req.GetProtoFile() + files = vanity.FilterFiles(files, vanity.NotInPackageGoogleProtobuf) + + vanity.ForEachFile(files, vanity.TurnOnMarshalerAll) + vanity.ForEachFile(files, vanity.TurnOnSizerAll) + vanity.ForEachFile(files, vanity.TurnOnUnmarshalerAll) + + vanity.ForEachFieldInFilesExcludingExtensions(vanity.OnlyProto2(files), vanity.TurnOffNullableForNativeTypesWithoutDefaultsOnly) + vanity.ForEachFile(files, vanity.TurnOffGoUnrecognizedAll) + + vanity.ForEachFile(files, vanity.TurnOffGoEnumPrefixAll) + vanity.ForEachFile(files, vanity.TurnOffGoEnumStringerAll) + vanity.ForEachFile(files, vanity.TurnOnEnumStringerAll) + + vanity.ForEachFile(files, vanity.TurnOnEqualAll) + vanity.ForEachFile(files, vanity.TurnOnGoStringAll) + vanity.ForEachFile(files, vanity.TurnOffGoStringerAll) + vanity.ForEachFile(files, vanity.TurnOnStringerAll) + + resp := command.Generate(req) + command.Write(resp) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-min-version/minversion.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-min-version/minversion.go new file mode 100644 index 0000000000000000000000000000000000000000..d55d85b08eb57ef665009fc46e371b5b5c261766 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-min-version/minversion.go @@ -0,0 +1,65 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 main + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/version" + "fmt" + "os" + "os/exec" + "strings" +) + +func filter(ss []string, flag string) ([]string, string) { + s := make([]string, 0, len(ss)) + var v string + for i := range ss { + if strings.Contains(ss[i], flag) { + vs := strings.Split(ss[i], "=") + v = vs[1] + continue + } + s = append(s, ss[i]) + } + return s, v +} + +func main() { + args, min := filter(os.Args[1:], "-version") + if !version.AtLeast(min) { + fmt.Printf("protoc version not high enough to parse this proto file\n") + return + } + gen := exec.Command("protoc", args...) + out, err := gen.CombinedOutput() + if err != nil { + fmt.Printf("%s\n", string(out)) + panic(err) + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/sortkeys/sortkeys.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/sortkeys/sortkeys.go new file mode 100644 index 0000000000000000000000000000000000000000..c52878dd5965a20df03da007099c4f501e42ae8e --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/sortkeys/sortkeys.go @@ -0,0 +1,99 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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 sortkeys + +import ( + "sort" +) + +func Strings(l []string) { + sort.Strings(l) +} + +func Float64s(l []float64) { + sort.Float64s(l) +} + +func Float32s(l []float32) { + sort.Sort(Float32Slice(l)) +} + +func Int64s(l []int64) { + sort.Sort(Int64Slice(l)) +} + +func Int32s(l []int32) { + sort.Sort(Int32Slice(l)) +} + +func Uint64s(l []uint64) { + sort.Sort(Uint64Slice(l)) +} + +func Uint32s(l []uint32) { + sort.Sort(Uint32Slice(l)) +} + +func Bools(l []bool) { + sort.Sort(BoolSlice(l)) +} + +type BoolSlice []bool + +func (p BoolSlice) Len() int { return len(p) } +func (p BoolSlice) Less(i, j int) bool { return p[j] } +func (p BoolSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +type Int64Slice []int64 + +func (p Int64Slice) Len() int { return len(p) } +func (p Int64Slice) Less(i, j int) bool { return p[i] < p[j] } +func (p Int64Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +type Int32Slice []int32 + +func (p Int32Slice) Len() int { return len(p) } +func (p Int32Slice) Less(i, j int) bool { return p[i] < p[j] } +func (p Int32Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +type Uint64Slice []uint64 + +func (p Uint64Slice) Len() int { return len(p) } +func (p Uint64Slice) Less(i, j int) bool { return p[i] < p[j] } +func (p Uint64Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +type Uint32Slice []uint32 + +func (p Uint32Slice) Len() int { return len(p) } +func (p Uint32Slice) Less(i, j int) bool { return p[i] < p[j] } +func (p Uint32Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } + +type Float32Slice []float32 + +func (p Float32Slice) Len() int { return len(p) } +func (p Float32Slice) Less(i, j int) bool { return p[i] < p[j] } +func (p Float32Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/.gitignore b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..773a6df9baff964b04b810b12fd29d8339efc790 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/.gitignore @@ -0,0 +1 @@ +*.dat diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..edcbe5048ec1e4b21da976902dcb744cb0283ed2 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/Makefile @@ -0,0 +1,44 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/protobuf/gogoproto +# +# 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. +# +# 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: + go install github.com/gogo/protobuf/protoc-gen-combo + protoc --gogo_out=. --proto_path=../:../../../../:../protobuf/:. thetest.proto + protoc-gen-combo --default=false --proto_path=../:../../../../:../protobuf/:. thetest.proto + cp uuid.go ./combos/both/ + cp uuid.go ./combos/marshaler/ + cp uuid.go ./combos/unmarshaler/ + cp uuid.go ./combos/unsafeboth/ + cp uuid.go ./combos/unsafemarshaler/ + cp uuid.go ./combos/unsafeunmarshaler/ + cp bug_test.go ./combos/both/ + cp bug_test.go ./combos/marshaler/ + cp bug_test.go ./combos/unmarshaler/ + cp bug_test.go ./combos/unsafeboth/ + cp bug_test.go ./combos/unsafemarshaler/ + cp bug_test.go ./combos/unsafeunmarshaler/ diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/bug_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/bug_test.go new file mode 100644 index 0000000000000000000000000000000000000000..264d3982327d7276cc42c9314074f391dde60dfa --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/bug_test.go @@ -0,0 +1,186 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 test + +import ( + "fmt" + "math" + "testing" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +) + +//http://code.google.com/p/goprotobuf/issues/detail?id=39 +func TestBugUint32VarintSize(t *testing.T) { + temp := uint32(math.MaxUint32) + n := &NinOptNative{} + n.Field5 = &temp + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != 6 { + t.Fatalf("data should be length 6, but its %#v", data) + } +} + +func TestBugZeroLengthSliceSize(t *testing.T) { + n := &NinRepPackedNative{ + Field8: []int64{}, + } + size := n.Size() + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != size { + t.Fatalf("expected %v, but got %v", len(data), size) + } +} + +//http://code.google.com/p/goprotobuf/issues/detail?id=40 +func TestBugPackedProtoSize(t *testing.T) { + n := &NinRepPackedNative{ + Field4: []int64{172960727389894724, 2360337516664475010, 860833876131988189, 9068073014890763245, 7794843386260381831, 4023536436053141786, 8992311247496919020, 4330096163611305776, 4490411416244976467, 7873947349172707443, 2754969595834279669, 1360667855926938684, 4771480785172657389, 4875578924966668055, 8070579869808877481, 9128179594766551001, 4630419407064527516, 863844540220372892, 8208727650143073487, 7086117356301045838, 7779695211931506151, 5493835345187563535, 9119767633370806007, 9054342025895349248, 1887303228838508438, 7624573031734528281, 1874668389749611225, 3517684643468970593, 6677697606628877758, 7293473953189936168, 444475066704085538, 8594971141363049302, 1146643249094989673, 733393306232853371, 7721178528893916886, 7784452000911004429, 6436373110242711440, 6897422461738321237, 8772249155667732778, 6211871464311393541, 3061903718310406883, 7845488913176136641, 8342255034663902574, 3443058984649725748, 8410801047334832902, 7496541071517841153, 4305416923521577765, 7814967600020476457, 8671843803465481186, 3490266370361096855, 1447425664719091336, 653218597262334239, 8306243902880091940, 7851896059762409081, 5936760560798954978, 5755724498441478025, 7022701569985035966, 3707709584811468220, 529069456924666920, 7986469043681522462, 3092513330689518836, 5103541550470476202, 3577384161242626406, 3733428084624703294, 8388690542440473117, 3262468785346149388, 8788358556558007570, 5476276940198542020, 7277903243119461239, 5065861426928605020, 7533460976202697734, 1749213838654236956, 557497603941617931, 5496307611456481108, 6444547750062831720, 6992758776744205596, 7356719693428537399, 2896328872476734507, 381447079530132038, 598300737753233118, 3687980626612697715, 7240924191084283349, 8172414415307971170, 4847024388701257185, 2081764168600256551, 3394217778539123488, 6244660626429310923, 8301712215675381614, 5360615125359461174, 8410140945829785773, 3152963269026381373, 6197275282781459633, 4419829061407546410, 6262035523070047537, 2837207483933463885, 2158105736666826128, 8150764172235490711}, + Field7: []int32{249451845, 1409974015, 393609128, 435232428, 1817529040, 91769006, 861170933, 1556185603, 1568580279, 1236375273, 512276621, 693633711, 967580535, 1950715977, 853431462, 1362390253, 159591204, 111900629, 322985263, 279671129, 1592548430, 465651370, 733849989, 1172059400, 1574824441, 263541092, 1271612397, 1520584358, 467078791, 117698716, 1098255064, 2054264846, 1766452305, 1267576395, 1557505617, 1187833560, 956187431, 1970977586, 1160235159, 1610259028, 489585797, 459139078, 566263183, 954319278, 1545018565, 1753946743, 948214318, 422878159, 883926576, 1424009347, 824732372, 1290433180, 80297942, 417294230, 1402647904, 2078392782, 220505045, 787368129, 463781454, 293083578, 808156928, 293976361}, + Field9: []uint32{0xaa4976e8, 0x3da8cc4c, 0x8c470d83, 0x344d964e, 0x5b90925, 0xa4c4d34e, 0x666eff19, 0xc238e552, 0x9be53bb6, 0x56364245, 0x33ee079d, 0x96bf0ede, 0x7941b74f, 0xdb07cb47, 0x6d76d827, 0x9b211d5d, 0x2798adb6, 0xe48b0c3b, 0x87061b21, 0x48f4e4d2, 0x3e5d5c12, 0x5ee91288, 0x336d4f35, 0xe1d44941, 0xc065548d, 0x2953d73f, 0x873af451, 0xfc769db, 0x9f1bf8da, 0x9baafdfc, 0xf1d3d770, 0x5bb5d2b4, 0xc2c67c48, 0x6845c4c1, 0xa48f32b0, 0xbb04bb70, 0xa5b1ca36, 0x8d98356a, 0x2171f654, 0x5ae279b0, 0x6c4a3d6b, 0x4fff5468, 0xcf9bf851, 0x68513614, 0xdbecd9b0, 0x9553ed3c, 0xa494a736, 0x42205438, 0xbf8e5caa, 0xd3283c6, 0x76d20788, 0x9179826f, 0x96b24f85, 0xbc2eacf4, 0xe4afae0b, 0x4bca85cb, 0x35e63b5b, 0xd7ccee0c, 0x2b506bb9, 0xe78e9f44, 0x9ad232f1, 0x99a37335, 0xa5d6ffc8}, + Field11: []uint64{0x53c01ebc, 0x4fb85ba6, 0x8805eea1, 0xb20ec896, 0x93b63410, 0xec7c9492, 0x50765a28, 0x19592106, 0x2ecc59b3, 0x39cd474f, 0xe4c9e47, 0x444f48c5, 0xe7731d32, 0xf3f43975, 0x603caedd, 0xbb05a1af, 0xa808e34e, 0x88580b07, 0x4c96bbd1, 0x730b4ab9, 0xed126e2b, 0x6db48205, 0x154ba1b9, 0xc26bfb6a, 0x389aa052, 0x869d966c, 0x7c86b366, 0xcc8edbcd, 0xfa8d6dad, 0xcf5857d9, 0x2d9cda0f, 0x1218a0b8, 0x41bf997, 0xf0ca65ac, 0xa610d4b9, 0x8d362e28, 0xb7212d87, 0x8e0fe109, 0xbee041d9, 0x759be2f6, 0x35fef4f3, 0xaeacdb71, 0x10888852, 0xf4e28117, 0xe2a14812, 0x73b748dc, 0xd1c3c6b2, 0xfef41bf0, 0xc9b43b62, 0x810e4faa, 0xcaa41c06, 0x1893fe0d, 0xedc7c850, 0xd12b9eaa, 0x467ee1a9, 0xbe84756b, 0xda7b1680, 0xdc069ffe, 0xf1e7e9f9, 0xb3d95370, 0xa92b77df, 0x5693ac41, 0xd04b7287, 0x27aebf15, 0x837b316e, 0x4dbe2263, 0xbab70c67, 0x547dab21, 0x3c346c1f, 0xb8ef0e4e, 0xfe2d03ce, 0xe1d75955, 0xfec1306, 0xba35c23e, 0xb784ed04, 0x2a4e33aa, 0x7e19d09a, 0x3827c1fe, 0xf3a51561, 0xef765e2b, 0xb044256c, 0x62b322be, 0xf34d56be, 0xeb71b369, 0xffe1294f, 0x237fe8d0, 0x77a1473b, 0x239e1196, 0xdd19bf3d, 0x82c91fe1, 0x95361c57, 0xffea3f1b, 0x1a094c84}, + Field12: []int64{8308420747267165049, 3664160795077875961, 7868970059161834817, 7237335984251173739, 5254748003907196506, 3362259627111837480, 430460752854552122, 5119635556501066533, 1277716037866233522, 9185775384759813768, 833932430882717888, 7986528304451297640, 6792233378368656337, 2074207091120609721, 1788723326198279432, 7756514594746453657, 2283775964901597324, 3061497730110517191, 7733947890656120277, 626967303632386244, 7822928600388582821, 3489658753000061230, 168869995163005961, 248814782163480763, 477885608911386247, 4198422415674133867, 3379354662797976109, 9925112544736939, 1486335136459138480, 4561560414032850671, 1010864164014091267, 186722821683803084, 5106357936724819318, 1298160820191228988, 4675403242419953145, 7130634540106489752, 7101280006672440929, 7176058292431955718, 9109875054097770321, 6810974877085322872, 4736707874303993641, 8993135362721382187, 6857881554990254283, 3704748883307461680, 1099360832887634994, 5207691918707192633, 5984721695043995243}, + } + size := proto.Size(n) + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != size { + t.Fatalf("expected %v, but got %v diff is %v", len(data), size, len(data)-size) + } +} + +func testSize(m interface { + proto.Message + Size() int +}, desc string, expected int) ([]byte, error) { + data, err := proto.Marshal(m) + if err != nil { + return nil, err + } + protoSize := proto.Size(m) + mSize := m.Size() + lenData := len(data) + if protoSize != mSize || protoSize != lenData || mSize != lenData { + return nil, fmt.Errorf("%s proto.Size(m){%d} != m.Size(){%d} != len(data){%d}", desc, protoSize, mSize, lenData) + } + if got := protoSize; got != expected { + return nil, fmt.Errorf("%s proto.Size(m) got %d expected %d", desc, got, expected) + } + if got := mSize; got != expected { + return nil, fmt.Errorf("%s m.Size() got %d expected %d", desc, got, expected) + } + if got := lenData; got != expected { + return nil, fmt.Errorf("%s len(data) got %d expected %d", desc, got, expected) + } + return data, nil +} + +func TestInt32Int64Compatibility(t *testing.T) { + + //test nullable int32 and int64 + + data1, err := testSize(&NinOptNative{ + Field3: proto.Int32(-1), + }, "nullable", 11) + if err != nil { + t.Error(err) + } + //change marshaled data1 to unmarshal into 4th field which is an int64 + data1[0] = uint8(uint32(4 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + u1 := &NinOptNative{} + if err := proto.Unmarshal(data1, u1); err != nil { + t.Error(err) + } + if !u1.Equal(&NinOptNative{ + Field4: proto.Int64(-1), + }) { + t.Error("nullable unmarshaled int32 is not the same int64") + } + + //test non-nullable int32 and int64 + + data2, err := testSize(&NidOptNative{ + Field3: -1, + }, "non nullable", 67) + if err != nil { + t.Error(err) + } + //change marshaled data2 to unmarshal into 4th field which is an int64 + field3 := uint8(uint32(3 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + field4 := uint8(uint32(4 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + for i, c := range data2 { + if c == field4 { + data2[i] = field3 + } else if c == field3 { + data2[i] = field4 + } + } + u2 := &NidOptNative{} + if err := proto.Unmarshal(data2, u2); err != nil { + t.Error(err) + } + if !u2.Equal(&NidOptNative{ + Field4: -1, + }) { + t.Error("non nullable unmarshaled int32 is not the same int64") + } + + //test packed repeated int32 and int64 + + m4 := &NinRepPackedNative{ + Field3: []int32{-1}, + } + data4, err := testSize(m4, "packed", 12) + if err != nil { + t.Error(err) + } + u4 := &NinRepPackedNative{} + if err := proto.Unmarshal(data4, u4); err != nil { + t.Error(err) + } + if err := u4.VerboseEqual(m4); err != nil { + t.Fatalf("%#v", u4) + } + + //test repeated int32 and int64 + + if _, err := testSize(&NinRepNative{ + Field3: []int32{-1}, + }, "repeated", 11); err != nil { + t.Error(err) + } + + t.Logf("tested all") +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..f3f1a492c7cdf63b539f8ae5ded3249db7e90e81 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/Makefile @@ -0,0 +1,31 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/protobuf/gogoproto +# +# 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. +# +# 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: + go install github.com/gogo/protobuf/protoc-gen-combo + protoc-gen-combo --version="3.0.0" --proto_path=../../../../../:../../protobuf/:. casttype.proto diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/casttype.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/casttype.proto new file mode 100644 index 0000000000000000000000000000000000000000..fbf99db178fd22ab3c41a58d048ea48bed1d214e --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/casttype.proto @@ -0,0 +1,66 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package casttype; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Castaway { + optional int64 Int32Ptr = 1 [(gogoproto.casttype) = "int32"]; + optional int64 Int32 = 2 [(gogoproto.nullable) = false, (gogoproto.casttype) = "int32"]; + optional uint64 MyUint64Ptr = 3 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + optional uint64 MyUint64 = 4 [(gogoproto.nullable) = false, (gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + optional bytes MyBytes = 5 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.Bytes"]; + optional bytes NormalBytes = 6; + repeated uint64 MyUint64s = 7 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/both/casttype.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/both/casttype.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..67afe26ef50394935db91ac36286e3effe1b220a --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/both/casttype.pb.go @@ -0,0 +1,2385 @@ +// Code generated by protoc-gen-gogo. +// source: combos/both/casttype.proto +// DO NOT EDIT! + +/* + Package casttype is a generated protocol buffer package. + + It is generated from these files: + combos/both/casttype.proto + + It has these top-level messages: + Castaway +*/ +package casttype + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_casttype "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Castaway struct { + Int32Ptr *int32 `protobuf:"varint,1,opt,name=Int32Ptr,casttype=int32" json:"Int32Ptr,omitempty"` + Int32 int32 `protobuf:"varint,2,opt,name=Int32,casttype=int32" json:"Int32"` + MyUint64Ptr *github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,3,opt,name=MyUint64Ptr,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64Ptr,omitempty"` + MyUint64 github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,4,opt,name=MyUint64,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64"` + MyBytes github_com_gogo_protobuf_test_casttype.Bytes `protobuf:"bytes,5,opt,name=MyBytes,casttype=github.com/gogo/protobuf/test/casttype.Bytes" json:"MyBytes,omitempty"` + NormalBytes []byte `protobuf:"bytes,6,opt,name=NormalBytes" json:"NormalBytes,omitempty"` + MyUint64S []github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,7,rep,name=MyUint64s,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64s,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Castaway) Reset() { *m = Castaway{} } +func (*Castaway) ProtoMessage() {} + +func (this *Castaway) Description() (desc *google_protobuf.FileDescriptorSet) { + return CasttypeDescription() +} +func CasttypeDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/both/casttype.proto"), + Package: func(v string) *string { return &v }("casttype"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Castaway"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Int32Ptr"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x5, 0x69, 0x6e, 0x74, 0x33, 0x32})}}, + }, {Name: func(v string) *string { return &v }("Int32"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x5, 0x69, 0x6e, 0x74, 0x33, 0x32})}}, + }, {Name: func(v string) *string { return &v }("MyUint64Ptr"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("MyUint64"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("MyBytes"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }, {Name: func(v string) *string { return &v }("NormalBytes"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("MyUint64s"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (this *Castaway) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Castaway) + if !ok { + return fmt.Errorf("that is not of type *Castaway") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Castaway but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Castawaybut is not nil && this == nil") + } + if this.Int32Ptr != nil && that1.Int32Ptr != nil { + if *this.Int32Ptr != *that1.Int32Ptr { + return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", *this.Int32Ptr, *that1.Int32Ptr) + } + } else if this.Int32Ptr != nil { + return fmt.Errorf("this.Int32Ptr == nil && that.Int32Ptr != nil") + } else if that1.Int32Ptr != nil { + return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", this.Int32Ptr, that1.Int32Ptr) + } + if this.Int32 != that1.Int32 { + return fmt.Errorf("Int32 this(%v) Not Equal that(%v)", this.Int32, that1.Int32) + } + if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil { + if *this.MyUint64Ptr != *that1.MyUint64Ptr { + return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", *this.MyUint64Ptr, *that1.MyUint64Ptr) + } + } else if this.MyUint64Ptr != nil { + return fmt.Errorf("this.MyUint64Ptr == nil && that.MyUint64Ptr != nil") + } else if that1.MyUint64Ptr != nil { + return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", this.MyUint64Ptr, that1.MyUint64Ptr) + } + if this.MyUint64 != that1.MyUint64 { + return fmt.Errorf("MyUint64 this(%v) Not Equal that(%v)", this.MyUint64, that1.MyUint64) + } + if !bytes.Equal(this.MyBytes, that1.MyBytes) { + return fmt.Errorf("MyBytes this(%v) Not Equal that(%v)", this.MyBytes, that1.MyBytes) + } + if !bytes.Equal(this.NormalBytes, that1.NormalBytes) { + return fmt.Errorf("NormalBytes this(%v) Not Equal that(%v)", this.NormalBytes, that1.NormalBytes) + } + if len(this.MyUint64S) != len(that1.MyUint64S) { + return fmt.Errorf("MyUint64S this(%v) Not Equal that(%v)", len(this.MyUint64S), len(that1.MyUint64S)) + } + for i := range this.MyUint64S { + if this.MyUint64S[i] != that1.MyUint64S[i] { + return fmt.Errorf("MyUint64S this[%v](%v) Not Equal that[%v](%v)", i, this.MyUint64S[i], i, that1.MyUint64S[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Castaway) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Castaway) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Int32Ptr != nil && that1.Int32Ptr != nil { + if *this.Int32Ptr != *that1.Int32Ptr { + return false + } + } else if this.Int32Ptr != nil { + return false + } else if that1.Int32Ptr != nil { + return false + } + if this.Int32 != that1.Int32 { + return false + } + if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil { + if *this.MyUint64Ptr != *that1.MyUint64Ptr { + return false + } + } else if this.MyUint64Ptr != nil { + return false + } else if that1.MyUint64Ptr != nil { + return false + } + if this.MyUint64 != that1.MyUint64 { + return false + } + if !bytes.Equal(this.MyBytes, that1.MyBytes) { + return false + } + if !bytes.Equal(this.NormalBytes, that1.NormalBytes) { + return false + } + if len(this.MyUint64S) != len(that1.MyUint64S) { + return false + } + for i := range this.MyUint64S { + if this.MyUint64S[i] != that1.MyUint64S[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} + +type CastawayFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetInt32Ptr() *int32 + GetInt32() int32 + GetMyUint64Ptr() *github_com_gogo_protobuf_test_casttype.MyUint64Type + GetMyUint64() github_com_gogo_protobuf_test_casttype.MyUint64Type + GetMyBytes() github_com_gogo_protobuf_test_casttype.Bytes + GetNormalBytes() []byte + GetMyUint64S() []github_com_gogo_protobuf_test_casttype.MyUint64Type +} + +func (this *Castaway) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Castaway) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCastawayFromFace(this) +} + +func (this *Castaway) GetInt32Ptr() *int32 { + return this.Int32Ptr +} + +func (this *Castaway) GetInt32() int32 { + return this.Int32 +} + +func (this *Castaway) GetMyUint64Ptr() *github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64Ptr +} + +func (this *Castaway) GetMyUint64() github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64 +} + +func (this *Castaway) GetMyBytes() github_com_gogo_protobuf_test_casttype.Bytes { + return this.MyBytes +} + +func (this *Castaway) GetNormalBytes() []byte { + return this.NormalBytes +} + +func (this *Castaway) GetMyUint64S() []github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64S +} + +func NewCastawayFromFace(that CastawayFace) *Castaway { + this := &Castaway{} + this.Int32Ptr = that.GetInt32Ptr() + this.Int32 = that.GetInt32() + this.MyUint64Ptr = that.GetMyUint64Ptr() + this.MyUint64 = that.GetMyUint64() + this.MyBytes = that.GetMyBytes() + this.NormalBytes = that.GetNormalBytes() + this.MyUint64S = that.GetMyUint64S() + return this +} + +func (this *Castaway) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 11) + s = append(s, "&casttype.Castaway{") + if this.Int32Ptr != nil { + s = append(s, "Int32Ptr: "+valueToGoStringCasttype(this.Int32Ptr, "int32")+",\n") + } + s = append(s, "Int32: "+fmt.Sprintf("%#v", this.Int32)+",\n") + if this.MyUint64Ptr != nil { + s = append(s, "MyUint64Ptr: "+valueToGoStringCasttype(this.MyUint64Ptr, "github_com_gogo_protobuf_test_casttype.MyUint64Type")+",\n") + } + s = append(s, "MyUint64: "+fmt.Sprintf("%#v", this.MyUint64)+",\n") + if this.MyBytes != nil { + s = append(s, "MyBytes: "+valueToGoStringCasttype(this.MyBytes, "github_com_gogo_protobuf_test_casttype.Bytes")+",\n") + } + if this.NormalBytes != nil { + s = append(s, "NormalBytes: "+valueToGoStringCasttype(this.NormalBytes, "byte")+",\n") + } + if this.MyUint64S != nil { + s = append(s, "MyUint64S: "+fmt.Sprintf("%#v", this.MyUint64S)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringCasttype(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringCasttype(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *Castaway) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Castaway) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Int32Ptr != nil { + data[i] = 0x8 + i++ + i = encodeVarintCasttype(data, i, uint64(*m.Int32Ptr)) + } + data[i] = 0x10 + i++ + i = encodeVarintCasttype(data, i, uint64(m.Int32)) + if m.MyUint64Ptr != nil { + data[i] = 0x18 + i++ + i = encodeVarintCasttype(data, i, uint64(*m.MyUint64Ptr)) + } + data[i] = 0x20 + i++ + i = encodeVarintCasttype(data, i, uint64(m.MyUint64)) + if m.MyBytes != nil { + data[i] = 0x2a + i++ + i = encodeVarintCasttype(data, i, uint64(len(m.MyBytes))) + i += copy(data[i:], m.MyBytes) + } + if m.NormalBytes != nil { + data[i] = 0x32 + i++ + i = encodeVarintCasttype(data, i, uint64(len(m.NormalBytes))) + i += copy(data[i:], m.NormalBytes) + } + if len(m.MyUint64S) > 0 { + for _, num := range m.MyUint64S { + data[i] = 0x38 + i++ + i = encodeVarintCasttype(data, i, uint64(num)) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Casttype(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Casttype(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintCasttype(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedCastaway(r randyCasttype, easy bool) *Castaway { + this := &Castaway{} + if r.Intn(10) != 0 { + v1 := int32(r.Int63()) + if r.Intn(2) == 0 { + v1 *= -1 + } + this.Int32Ptr = &v1 + } + this.Int32 = int32(r.Int63()) + if r.Intn(2) == 0 { + this.Int32 *= -1 + } + if r.Intn(10) != 0 { + v2 := github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + this.MyUint64Ptr = &v2 + } + this.MyUint64 = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + if r.Intn(10) != 0 { + v3 := r.Intn(100) + this.MyBytes = make(github_com_gogo_protobuf_test_casttype.Bytes, v3) + for i := 0; i < v3; i++ { + this.MyBytes[i] = byte(r.Intn(256)) + } + } + if r.Intn(10) != 0 { + v4 := r.Intn(100) + this.NormalBytes = make([]byte, v4) + for i := 0; i < v4; i++ { + this.NormalBytes[i] = byte(r.Intn(256)) + } + } + if r.Intn(10) != 0 { + v5 := r.Intn(100) + this.MyUint64S = make([]github_com_gogo_protobuf_test_casttype.MyUint64Type, v5) + for i := 0; i < v5; i++ { + this.MyUint64S[i] = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedCasttype(r, 8) + } + return this +} + +type randyCasttype interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneCasttype(r randyCasttype) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringCasttype(r randyCasttype) string { + v6 := r.Intn(100) + tmps := make([]rune, v6) + for i := 0; i < v6; i++ { + tmps[i] = randUTF8RuneCasttype(r) + } + return string(tmps) +} +func randUnrecognizedCasttype(r randyCasttype, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldCasttype(data, r, fieldNumber, wire) + } + return data +} +func randFieldCasttype(data []byte, r randyCasttype, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateCasttype(data, uint64(key)) + v7 := r.Int63() + if r.Intn(2) == 0 { + v7 *= -1 + } + data = encodeVarintPopulateCasttype(data, uint64(v7)) + case 1: + data = encodeVarintPopulateCasttype(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateCasttype(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateCasttype(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateCasttype(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateCasttype(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Castaway) Size() (n int) { + var l int + _ = l + if m.Int32Ptr != nil { + n += 1 + sovCasttype(uint64(*m.Int32Ptr)) + } + n += 1 + sovCasttype(uint64(m.Int32)) + if m.MyUint64Ptr != nil { + n += 1 + sovCasttype(uint64(*m.MyUint64Ptr)) + } + n += 1 + sovCasttype(uint64(m.MyUint64)) + if m.MyBytes != nil { + l = len(m.MyBytes) + n += 1 + l + sovCasttype(uint64(l)) + } + if m.NormalBytes != nil { + l = len(m.NormalBytes) + n += 1 + l + sovCasttype(uint64(l)) + } + if len(m.MyUint64S) > 0 { + for _, e := range m.MyUint64S { + n += 1 + sovCasttype(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovCasttype(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozCasttype(x uint64) (n int) { + return sovCasttype(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Castaway) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Castaway{`, + `Int32Ptr:` + valueToStringCasttype(this.Int32Ptr) + `,`, + `Int32:` + fmt.Sprintf("%v", this.Int32) + `,`, + `MyUint64Ptr:` + valueToStringCasttype(this.MyUint64Ptr) + `,`, + `MyUint64:` + fmt.Sprintf("%v", this.MyUint64) + `,`, + `MyBytes:` + valueToStringCasttype(this.MyBytes) + `,`, + `NormalBytes:` + valueToStringCasttype(this.NormalBytes) + `,`, + `MyUint64S:` + fmt.Sprintf("%v", this.MyUint64S) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringCasttype(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Castaway) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttype + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Castaway: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Castaway: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32Ptr", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttype + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Int32Ptr = &v + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32", wireType) + } + m.Int32 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttype + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Int32 |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyUint64Ptr", wireType) + } + var v github_com_gogo_protobuf_test_casttype.MyUint64Type + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttype + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (github_com_gogo_protobuf_test_casttype.MyUint64Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MyUint64Ptr = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyUint64", wireType) + } + m.MyUint64 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttype + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.MyUint64 |= (github_com_gogo_protobuf_test_casttype.MyUint64Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MyBytes", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttype + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCasttype + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MyBytes = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NormalBytes", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttype + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCasttype + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NormalBytes = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyUint64S", wireType) + } + var v github_com_gogo_protobuf_test_casttype.MyUint64Type + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttype + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (github_com_gogo_protobuf_test_casttype.MyUint64Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MyUint64S = append(m.MyUint64S, v) + default: + iNdEx = preIndex + skippy, err := skipCasttype(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthCasttype + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipCasttype(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCasttype + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCasttype + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCasttype + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthCasttype + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCasttype + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipCasttype(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthCasttype = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowCasttype = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/both/casttype.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/both/casttype.proto new file mode 100644 index 0000000000000000000000000000000000000000..617fe3986f532145a5d6b34a0e99e26f4502ccb9 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/both/casttype.proto @@ -0,0 +1,66 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package casttype; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Castaway { + optional int64 Int32Ptr = 1 [(gogoproto.casttype) = "int32"]; + optional int64 Int32 = 2 [(gogoproto.nullable) = false, (gogoproto.casttype) = "int32"]; + optional uint64 MyUint64Ptr = 3 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + optional uint64 MyUint64 = 4 [(gogoproto.nullable) = false, (gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + optional bytes MyBytes = 5 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.Bytes"]; + optional bytes NormalBytes = 6; + repeated uint64 MyUint64s = 7 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/both/casttypepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/both/casttypepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..0e816dd46c65b07878ef6f6a8f273911298d5cdd --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/both/casttypepb_test.go @@ -0,0 +1,275 @@ +// Code generated by protoc-gen-gogo. +// source: combos/both/casttype.proto +// DO NOT EDIT! + +/* +Package casttype is a generated protocol buffer package. + +It is generated from these files: + combos/both/casttype.proto + +It has these top-level messages: + Castaway +*/ +package casttype + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestCastawayProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCastawayMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCastawayProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Castaway, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCastaway(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCastawayProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCastaway(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Castaway{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCastawayJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCastawayProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCastawayProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCasttypeDescription(t *testing.T) { + CasttypeDescription() +} +func TestCastawayVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCastawayFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCastawayGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCastawaySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCastawaySize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Castaway, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCastaway(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCastawayStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/marshaler/casttype.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/marshaler/casttype.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..a8cc50a9602ff1cdb225f427b50de17112e7f5f3 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/marshaler/casttype.pb.go @@ -0,0 +1,2074 @@ +// Code generated by protoc-gen-gogo. +// source: combos/marshaler/casttype.proto +// DO NOT EDIT! + +/* +Package casttype is a generated protocol buffer package. + +It is generated from these files: + combos/marshaler/casttype.proto + +It has these top-level messages: + Castaway +*/ +package casttype + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_casttype "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Castaway struct { + Int32Ptr *int32 `protobuf:"varint,1,opt,name=Int32Ptr,casttype=int32" json:"Int32Ptr,omitempty"` + Int32 int32 `protobuf:"varint,2,opt,name=Int32,casttype=int32" json:"Int32"` + MyUint64Ptr *github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,3,opt,name=MyUint64Ptr,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64Ptr,omitempty"` + MyUint64 github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,4,opt,name=MyUint64,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64"` + MyBytes github_com_gogo_protobuf_test_casttype.Bytes `protobuf:"bytes,5,opt,name=MyBytes,casttype=github.com/gogo/protobuf/test/casttype.Bytes" json:"MyBytes,omitempty"` + NormalBytes []byte `protobuf:"bytes,6,opt,name=NormalBytes" json:"NormalBytes,omitempty"` + MyUint64S []github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,7,rep,name=MyUint64s,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64s,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Castaway) Reset() { *m = Castaway{} } +func (*Castaway) ProtoMessage() {} + +func (this *Castaway) Description() (desc *google_protobuf.FileDescriptorSet) { + return CasttypeDescription() +} +func CasttypeDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/marshaler/casttype.proto"), + Package: func(v string) *string { return &v }("casttype"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Castaway"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Int32Ptr"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x5, 0x69, 0x6e, 0x74, 0x33, 0x32})}}, + }, {Name: func(v string) *string { return &v }("Int32"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x5, 0x69, 0x6e, 0x74, 0x33, 0x32})}}, + }, {Name: func(v string) *string { return &v }("MyUint64Ptr"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("MyUint64"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("MyBytes"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }, {Name: func(v string) *string { return &v }("NormalBytes"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("MyUint64s"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (this *Castaway) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Castaway) + if !ok { + return fmt.Errorf("that is not of type *Castaway") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Castaway but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Castawaybut is not nil && this == nil") + } + if this.Int32Ptr != nil && that1.Int32Ptr != nil { + if *this.Int32Ptr != *that1.Int32Ptr { + return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", *this.Int32Ptr, *that1.Int32Ptr) + } + } else if this.Int32Ptr != nil { + return fmt.Errorf("this.Int32Ptr == nil && that.Int32Ptr != nil") + } else if that1.Int32Ptr != nil { + return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", this.Int32Ptr, that1.Int32Ptr) + } + if this.Int32 != that1.Int32 { + return fmt.Errorf("Int32 this(%v) Not Equal that(%v)", this.Int32, that1.Int32) + } + if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil { + if *this.MyUint64Ptr != *that1.MyUint64Ptr { + return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", *this.MyUint64Ptr, *that1.MyUint64Ptr) + } + } else if this.MyUint64Ptr != nil { + return fmt.Errorf("this.MyUint64Ptr == nil && that.MyUint64Ptr != nil") + } else if that1.MyUint64Ptr != nil { + return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", this.MyUint64Ptr, that1.MyUint64Ptr) + } + if this.MyUint64 != that1.MyUint64 { + return fmt.Errorf("MyUint64 this(%v) Not Equal that(%v)", this.MyUint64, that1.MyUint64) + } + if !bytes.Equal(this.MyBytes, that1.MyBytes) { + return fmt.Errorf("MyBytes this(%v) Not Equal that(%v)", this.MyBytes, that1.MyBytes) + } + if !bytes.Equal(this.NormalBytes, that1.NormalBytes) { + return fmt.Errorf("NormalBytes this(%v) Not Equal that(%v)", this.NormalBytes, that1.NormalBytes) + } + if len(this.MyUint64S) != len(that1.MyUint64S) { + return fmt.Errorf("MyUint64S this(%v) Not Equal that(%v)", len(this.MyUint64S), len(that1.MyUint64S)) + } + for i := range this.MyUint64S { + if this.MyUint64S[i] != that1.MyUint64S[i] { + return fmt.Errorf("MyUint64S this[%v](%v) Not Equal that[%v](%v)", i, this.MyUint64S[i], i, that1.MyUint64S[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Castaway) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Castaway) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Int32Ptr != nil && that1.Int32Ptr != nil { + if *this.Int32Ptr != *that1.Int32Ptr { + return false + } + } else if this.Int32Ptr != nil { + return false + } else if that1.Int32Ptr != nil { + return false + } + if this.Int32 != that1.Int32 { + return false + } + if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil { + if *this.MyUint64Ptr != *that1.MyUint64Ptr { + return false + } + } else if this.MyUint64Ptr != nil { + return false + } else if that1.MyUint64Ptr != nil { + return false + } + if this.MyUint64 != that1.MyUint64 { + return false + } + if !bytes.Equal(this.MyBytes, that1.MyBytes) { + return false + } + if !bytes.Equal(this.NormalBytes, that1.NormalBytes) { + return false + } + if len(this.MyUint64S) != len(that1.MyUint64S) { + return false + } + for i := range this.MyUint64S { + if this.MyUint64S[i] != that1.MyUint64S[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} + +type CastawayFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetInt32Ptr() *int32 + GetInt32() int32 + GetMyUint64Ptr() *github_com_gogo_protobuf_test_casttype.MyUint64Type + GetMyUint64() github_com_gogo_protobuf_test_casttype.MyUint64Type + GetMyBytes() github_com_gogo_protobuf_test_casttype.Bytes + GetNormalBytes() []byte + GetMyUint64S() []github_com_gogo_protobuf_test_casttype.MyUint64Type +} + +func (this *Castaway) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Castaway) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCastawayFromFace(this) +} + +func (this *Castaway) GetInt32Ptr() *int32 { + return this.Int32Ptr +} + +func (this *Castaway) GetInt32() int32 { + return this.Int32 +} + +func (this *Castaway) GetMyUint64Ptr() *github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64Ptr +} + +func (this *Castaway) GetMyUint64() github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64 +} + +func (this *Castaway) GetMyBytes() github_com_gogo_protobuf_test_casttype.Bytes { + return this.MyBytes +} + +func (this *Castaway) GetNormalBytes() []byte { + return this.NormalBytes +} + +func (this *Castaway) GetMyUint64S() []github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64S +} + +func NewCastawayFromFace(that CastawayFace) *Castaway { + this := &Castaway{} + this.Int32Ptr = that.GetInt32Ptr() + this.Int32 = that.GetInt32() + this.MyUint64Ptr = that.GetMyUint64Ptr() + this.MyUint64 = that.GetMyUint64() + this.MyBytes = that.GetMyBytes() + this.NormalBytes = that.GetNormalBytes() + this.MyUint64S = that.GetMyUint64S() + return this +} + +func (this *Castaway) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 11) + s = append(s, "&casttype.Castaway{") + if this.Int32Ptr != nil { + s = append(s, "Int32Ptr: "+valueToGoStringCasttype(this.Int32Ptr, "int32")+",\n") + } + s = append(s, "Int32: "+fmt.Sprintf("%#v", this.Int32)+",\n") + if this.MyUint64Ptr != nil { + s = append(s, "MyUint64Ptr: "+valueToGoStringCasttype(this.MyUint64Ptr, "github_com_gogo_protobuf_test_casttype.MyUint64Type")+",\n") + } + s = append(s, "MyUint64: "+fmt.Sprintf("%#v", this.MyUint64)+",\n") + if this.MyBytes != nil { + s = append(s, "MyBytes: "+valueToGoStringCasttype(this.MyBytes, "github_com_gogo_protobuf_test_casttype.Bytes")+",\n") + } + if this.NormalBytes != nil { + s = append(s, "NormalBytes: "+valueToGoStringCasttype(this.NormalBytes, "byte")+",\n") + } + if this.MyUint64S != nil { + s = append(s, "MyUint64S: "+fmt.Sprintf("%#v", this.MyUint64S)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringCasttype(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringCasttype(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *Castaway) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Castaway) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Int32Ptr != nil { + data[i] = 0x8 + i++ + i = encodeVarintCasttype(data, i, uint64(*m.Int32Ptr)) + } + data[i] = 0x10 + i++ + i = encodeVarintCasttype(data, i, uint64(m.Int32)) + if m.MyUint64Ptr != nil { + data[i] = 0x18 + i++ + i = encodeVarintCasttype(data, i, uint64(*m.MyUint64Ptr)) + } + data[i] = 0x20 + i++ + i = encodeVarintCasttype(data, i, uint64(m.MyUint64)) + if m.MyBytes != nil { + data[i] = 0x2a + i++ + i = encodeVarintCasttype(data, i, uint64(len(m.MyBytes))) + i += copy(data[i:], m.MyBytes) + } + if m.NormalBytes != nil { + data[i] = 0x32 + i++ + i = encodeVarintCasttype(data, i, uint64(len(m.NormalBytes))) + i += copy(data[i:], m.NormalBytes) + } + if len(m.MyUint64S) > 0 { + for _, num := range m.MyUint64S { + data[i] = 0x38 + i++ + i = encodeVarintCasttype(data, i, uint64(num)) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Casttype(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Casttype(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintCasttype(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedCastaway(r randyCasttype, easy bool) *Castaway { + this := &Castaway{} + if r.Intn(10) != 0 { + v1 := int32(r.Int63()) + if r.Intn(2) == 0 { + v1 *= -1 + } + this.Int32Ptr = &v1 + } + this.Int32 = int32(r.Int63()) + if r.Intn(2) == 0 { + this.Int32 *= -1 + } + if r.Intn(10) != 0 { + v2 := github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + this.MyUint64Ptr = &v2 + } + this.MyUint64 = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + if r.Intn(10) != 0 { + v3 := r.Intn(100) + this.MyBytes = make(github_com_gogo_protobuf_test_casttype.Bytes, v3) + for i := 0; i < v3; i++ { + this.MyBytes[i] = byte(r.Intn(256)) + } + } + if r.Intn(10) != 0 { + v4 := r.Intn(100) + this.NormalBytes = make([]byte, v4) + for i := 0; i < v4; i++ { + this.NormalBytes[i] = byte(r.Intn(256)) + } + } + if r.Intn(10) != 0 { + v5 := r.Intn(100) + this.MyUint64S = make([]github_com_gogo_protobuf_test_casttype.MyUint64Type, v5) + for i := 0; i < v5; i++ { + this.MyUint64S[i] = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedCasttype(r, 8) + } + return this +} + +type randyCasttype interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneCasttype(r randyCasttype) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringCasttype(r randyCasttype) string { + v6 := r.Intn(100) + tmps := make([]rune, v6) + for i := 0; i < v6; i++ { + tmps[i] = randUTF8RuneCasttype(r) + } + return string(tmps) +} +func randUnrecognizedCasttype(r randyCasttype, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldCasttype(data, r, fieldNumber, wire) + } + return data +} +func randFieldCasttype(data []byte, r randyCasttype, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateCasttype(data, uint64(key)) + v7 := r.Int63() + if r.Intn(2) == 0 { + v7 *= -1 + } + data = encodeVarintPopulateCasttype(data, uint64(v7)) + case 1: + data = encodeVarintPopulateCasttype(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateCasttype(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateCasttype(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateCasttype(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateCasttype(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Castaway) Size() (n int) { + var l int + _ = l + if m.Int32Ptr != nil { + n += 1 + sovCasttype(uint64(*m.Int32Ptr)) + } + n += 1 + sovCasttype(uint64(m.Int32)) + if m.MyUint64Ptr != nil { + n += 1 + sovCasttype(uint64(*m.MyUint64Ptr)) + } + n += 1 + sovCasttype(uint64(m.MyUint64)) + if m.MyBytes != nil { + l = len(m.MyBytes) + n += 1 + l + sovCasttype(uint64(l)) + } + if m.NormalBytes != nil { + l = len(m.NormalBytes) + n += 1 + l + sovCasttype(uint64(l)) + } + if len(m.MyUint64S) > 0 { + for _, e := range m.MyUint64S { + n += 1 + sovCasttype(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovCasttype(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozCasttype(x uint64) (n int) { + return sovCasttype(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Castaway) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Castaway{`, + `Int32Ptr:` + valueToStringCasttype(this.Int32Ptr) + `,`, + `Int32:` + fmt.Sprintf("%v", this.Int32) + `,`, + `MyUint64Ptr:` + valueToStringCasttype(this.MyUint64Ptr) + `,`, + `MyUint64:` + fmt.Sprintf("%v", this.MyUint64) + `,`, + `MyBytes:` + valueToStringCasttype(this.MyBytes) + `,`, + `NormalBytes:` + valueToStringCasttype(this.NormalBytes) + `,`, + `MyUint64S:` + fmt.Sprintf("%v", this.MyUint64S) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringCasttype(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/marshaler/casttype.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/marshaler/casttype.proto new file mode 100644 index 0000000000000000000000000000000000000000..71937207833922cfd257aeeced006f4e3ec4699a --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/marshaler/casttype.proto @@ -0,0 +1,66 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package casttype; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Castaway { + optional int64 Int32Ptr = 1 [(gogoproto.casttype) = "int32"]; + optional int64 Int32 = 2 [(gogoproto.nullable) = false, (gogoproto.casttype) = "int32"]; + optional uint64 MyUint64Ptr = 3 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + optional uint64 MyUint64 = 4 [(gogoproto.nullable) = false, (gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + optional bytes MyBytes = 5 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.Bytes"]; + optional bytes NormalBytes = 6; + repeated uint64 MyUint64s = 7 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/marshaler/casttypepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/marshaler/casttypepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..f5d68b31a91e5a70445a7699fb157ff48ac89e9f --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/marshaler/casttypepb_test.go @@ -0,0 +1,275 @@ +// Code generated by protoc-gen-gogo. +// source: combos/marshaler/casttype.proto +// DO NOT EDIT! + +/* +Package casttype is a generated protocol buffer package. + +It is generated from these files: + combos/marshaler/casttype.proto + +It has these top-level messages: + Castaway +*/ +package casttype + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestCastawayProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCastawayMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCastawayProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Castaway, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCastaway(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCastawayProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCastaway(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Castaway{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCastawayJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCastawayProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCastawayProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCasttypeDescription(t *testing.T) { + CasttypeDescription() +} +func TestCastawayVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCastawayFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCastawayGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCastawaySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCastawaySize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Castaway, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCastaway(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCastawayStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/neither/casttype.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/neither/casttype.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..a07c496add8579f28592b6e73d952507c63ffe4a --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/neither/casttype.pb.go @@ -0,0 +1,1991 @@ +// Code generated by protoc-gen-gogo. +// source: combos/neither/casttype.proto +// DO NOT EDIT! + +/* +Package casttype is a generated protocol buffer package. + +It is generated from these files: + combos/neither/casttype.proto + +It has these top-level messages: + Castaway +*/ +package casttype + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_casttype "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Castaway struct { + Int32Ptr *int32 `protobuf:"varint,1,opt,name=Int32Ptr,casttype=int32" json:"Int32Ptr,omitempty"` + Int32 int32 `protobuf:"varint,2,opt,name=Int32,casttype=int32" json:"Int32"` + MyUint64Ptr *github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,3,opt,name=MyUint64Ptr,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64Ptr,omitempty"` + MyUint64 github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,4,opt,name=MyUint64,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64"` + MyBytes github_com_gogo_protobuf_test_casttype.Bytes `protobuf:"bytes,5,opt,name=MyBytes,casttype=github.com/gogo/protobuf/test/casttype.Bytes" json:"MyBytes,omitempty"` + NormalBytes []byte `protobuf:"bytes,6,opt,name=NormalBytes" json:"NormalBytes,omitempty"` + MyUint64S []github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,7,rep,name=MyUint64s,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64s,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Castaway) Reset() { *m = Castaway{} } +func (*Castaway) ProtoMessage() {} + +func (this *Castaway) Description() (desc *google_protobuf.FileDescriptorSet) { + return CasttypeDescription() +} +func CasttypeDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/neither/casttype.proto"), + Package: func(v string) *string { return &v }("casttype"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Castaway"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Int32Ptr"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x5, 0x69, 0x6e, 0x74, 0x33, 0x32})}}, + }, {Name: func(v string) *string { return &v }("Int32"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x5, 0x69, 0x6e, 0x74, 0x33, 0x32})}}, + }, {Name: func(v string) *string { return &v }("MyUint64Ptr"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("MyUint64"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("MyBytes"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }, {Name: func(v string) *string { return &v }("NormalBytes"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("MyUint64s"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (this *Castaway) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Castaway) + if !ok { + return fmt.Errorf("that is not of type *Castaway") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Castaway but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Castawaybut is not nil && this == nil") + } + if this.Int32Ptr != nil && that1.Int32Ptr != nil { + if *this.Int32Ptr != *that1.Int32Ptr { + return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", *this.Int32Ptr, *that1.Int32Ptr) + } + } else if this.Int32Ptr != nil { + return fmt.Errorf("this.Int32Ptr == nil && that.Int32Ptr != nil") + } else if that1.Int32Ptr != nil { + return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", this.Int32Ptr, that1.Int32Ptr) + } + if this.Int32 != that1.Int32 { + return fmt.Errorf("Int32 this(%v) Not Equal that(%v)", this.Int32, that1.Int32) + } + if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil { + if *this.MyUint64Ptr != *that1.MyUint64Ptr { + return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", *this.MyUint64Ptr, *that1.MyUint64Ptr) + } + } else if this.MyUint64Ptr != nil { + return fmt.Errorf("this.MyUint64Ptr == nil && that.MyUint64Ptr != nil") + } else if that1.MyUint64Ptr != nil { + return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", this.MyUint64Ptr, that1.MyUint64Ptr) + } + if this.MyUint64 != that1.MyUint64 { + return fmt.Errorf("MyUint64 this(%v) Not Equal that(%v)", this.MyUint64, that1.MyUint64) + } + if !bytes.Equal(this.MyBytes, that1.MyBytes) { + return fmt.Errorf("MyBytes this(%v) Not Equal that(%v)", this.MyBytes, that1.MyBytes) + } + if !bytes.Equal(this.NormalBytes, that1.NormalBytes) { + return fmt.Errorf("NormalBytes this(%v) Not Equal that(%v)", this.NormalBytes, that1.NormalBytes) + } + if len(this.MyUint64S) != len(that1.MyUint64S) { + return fmt.Errorf("MyUint64S this(%v) Not Equal that(%v)", len(this.MyUint64S), len(that1.MyUint64S)) + } + for i := range this.MyUint64S { + if this.MyUint64S[i] != that1.MyUint64S[i] { + return fmt.Errorf("MyUint64S this[%v](%v) Not Equal that[%v](%v)", i, this.MyUint64S[i], i, that1.MyUint64S[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Castaway) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Castaway) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Int32Ptr != nil && that1.Int32Ptr != nil { + if *this.Int32Ptr != *that1.Int32Ptr { + return false + } + } else if this.Int32Ptr != nil { + return false + } else if that1.Int32Ptr != nil { + return false + } + if this.Int32 != that1.Int32 { + return false + } + if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil { + if *this.MyUint64Ptr != *that1.MyUint64Ptr { + return false + } + } else if this.MyUint64Ptr != nil { + return false + } else if that1.MyUint64Ptr != nil { + return false + } + if this.MyUint64 != that1.MyUint64 { + return false + } + if !bytes.Equal(this.MyBytes, that1.MyBytes) { + return false + } + if !bytes.Equal(this.NormalBytes, that1.NormalBytes) { + return false + } + if len(this.MyUint64S) != len(that1.MyUint64S) { + return false + } + for i := range this.MyUint64S { + if this.MyUint64S[i] != that1.MyUint64S[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} + +type CastawayFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetInt32Ptr() *int32 + GetInt32() int32 + GetMyUint64Ptr() *github_com_gogo_protobuf_test_casttype.MyUint64Type + GetMyUint64() github_com_gogo_protobuf_test_casttype.MyUint64Type + GetMyBytes() github_com_gogo_protobuf_test_casttype.Bytes + GetNormalBytes() []byte + GetMyUint64S() []github_com_gogo_protobuf_test_casttype.MyUint64Type +} + +func (this *Castaway) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Castaway) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCastawayFromFace(this) +} + +func (this *Castaway) GetInt32Ptr() *int32 { + return this.Int32Ptr +} + +func (this *Castaway) GetInt32() int32 { + return this.Int32 +} + +func (this *Castaway) GetMyUint64Ptr() *github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64Ptr +} + +func (this *Castaway) GetMyUint64() github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64 +} + +func (this *Castaway) GetMyBytes() github_com_gogo_protobuf_test_casttype.Bytes { + return this.MyBytes +} + +func (this *Castaway) GetNormalBytes() []byte { + return this.NormalBytes +} + +func (this *Castaway) GetMyUint64S() []github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64S +} + +func NewCastawayFromFace(that CastawayFace) *Castaway { + this := &Castaway{} + this.Int32Ptr = that.GetInt32Ptr() + this.Int32 = that.GetInt32() + this.MyUint64Ptr = that.GetMyUint64Ptr() + this.MyUint64 = that.GetMyUint64() + this.MyBytes = that.GetMyBytes() + this.NormalBytes = that.GetNormalBytes() + this.MyUint64S = that.GetMyUint64S() + return this +} + +func (this *Castaway) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 11) + s = append(s, "&casttype.Castaway{") + if this.Int32Ptr != nil { + s = append(s, "Int32Ptr: "+valueToGoStringCasttype(this.Int32Ptr, "int32")+",\n") + } + s = append(s, "Int32: "+fmt.Sprintf("%#v", this.Int32)+",\n") + if this.MyUint64Ptr != nil { + s = append(s, "MyUint64Ptr: "+valueToGoStringCasttype(this.MyUint64Ptr, "github_com_gogo_protobuf_test_casttype.MyUint64Type")+",\n") + } + s = append(s, "MyUint64: "+fmt.Sprintf("%#v", this.MyUint64)+",\n") + if this.MyBytes != nil { + s = append(s, "MyBytes: "+valueToGoStringCasttype(this.MyBytes, "github_com_gogo_protobuf_test_casttype.Bytes")+",\n") + } + if this.NormalBytes != nil { + s = append(s, "NormalBytes: "+valueToGoStringCasttype(this.NormalBytes, "byte")+",\n") + } + if this.MyUint64S != nil { + s = append(s, "MyUint64S: "+fmt.Sprintf("%#v", this.MyUint64S)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringCasttype(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringCasttype(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedCastaway(r randyCasttype, easy bool) *Castaway { + this := &Castaway{} + if r.Intn(10) != 0 { + v1 := int32(r.Int63()) + if r.Intn(2) == 0 { + v1 *= -1 + } + this.Int32Ptr = &v1 + } + this.Int32 = int32(r.Int63()) + if r.Intn(2) == 0 { + this.Int32 *= -1 + } + if r.Intn(10) != 0 { + v2 := github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + this.MyUint64Ptr = &v2 + } + this.MyUint64 = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + if r.Intn(10) != 0 { + v3 := r.Intn(100) + this.MyBytes = make(github_com_gogo_protobuf_test_casttype.Bytes, v3) + for i := 0; i < v3; i++ { + this.MyBytes[i] = byte(r.Intn(256)) + } + } + if r.Intn(10) != 0 { + v4 := r.Intn(100) + this.NormalBytes = make([]byte, v4) + for i := 0; i < v4; i++ { + this.NormalBytes[i] = byte(r.Intn(256)) + } + } + if r.Intn(10) != 0 { + v5 := r.Intn(100) + this.MyUint64S = make([]github_com_gogo_protobuf_test_casttype.MyUint64Type, v5) + for i := 0; i < v5; i++ { + this.MyUint64S[i] = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedCasttype(r, 8) + } + return this +} + +type randyCasttype interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneCasttype(r randyCasttype) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringCasttype(r randyCasttype) string { + v6 := r.Intn(100) + tmps := make([]rune, v6) + for i := 0; i < v6; i++ { + tmps[i] = randUTF8RuneCasttype(r) + } + return string(tmps) +} +func randUnrecognizedCasttype(r randyCasttype, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldCasttype(data, r, fieldNumber, wire) + } + return data +} +func randFieldCasttype(data []byte, r randyCasttype, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateCasttype(data, uint64(key)) + v7 := r.Int63() + if r.Intn(2) == 0 { + v7 *= -1 + } + data = encodeVarintPopulateCasttype(data, uint64(v7)) + case 1: + data = encodeVarintPopulateCasttype(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateCasttype(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateCasttype(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateCasttype(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateCasttype(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Castaway) Size() (n int) { + var l int + _ = l + if m.Int32Ptr != nil { + n += 1 + sovCasttype(uint64(*m.Int32Ptr)) + } + n += 1 + sovCasttype(uint64(m.Int32)) + if m.MyUint64Ptr != nil { + n += 1 + sovCasttype(uint64(*m.MyUint64Ptr)) + } + n += 1 + sovCasttype(uint64(m.MyUint64)) + if m.MyBytes != nil { + l = len(m.MyBytes) + n += 1 + l + sovCasttype(uint64(l)) + } + if m.NormalBytes != nil { + l = len(m.NormalBytes) + n += 1 + l + sovCasttype(uint64(l)) + } + if len(m.MyUint64S) > 0 { + for _, e := range m.MyUint64S { + n += 1 + sovCasttype(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovCasttype(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozCasttype(x uint64) (n int) { + return sovCasttype(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Castaway) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Castaway{`, + `Int32Ptr:` + valueToStringCasttype(this.Int32Ptr) + `,`, + `Int32:` + fmt.Sprintf("%v", this.Int32) + `,`, + `MyUint64Ptr:` + valueToStringCasttype(this.MyUint64Ptr) + `,`, + `MyUint64:` + fmt.Sprintf("%v", this.MyUint64) + `,`, + `MyBytes:` + valueToStringCasttype(this.MyBytes) + `,`, + `NormalBytes:` + valueToStringCasttype(this.NormalBytes) + `,`, + `MyUint64S:` + fmt.Sprintf("%v", this.MyUint64S) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringCasttype(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/neither/casttype.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/neither/casttype.proto new file mode 100644 index 0000000000000000000000000000000000000000..fbf99db178fd22ab3c41a58d048ea48bed1d214e --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/neither/casttype.proto @@ -0,0 +1,66 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package casttype; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Castaway { + optional int64 Int32Ptr = 1 [(gogoproto.casttype) = "int32"]; + optional int64 Int32 = 2 [(gogoproto.nullable) = false, (gogoproto.casttype) = "int32"]; + optional uint64 MyUint64Ptr = 3 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + optional uint64 MyUint64 = 4 [(gogoproto.nullable) = false, (gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + optional bytes MyBytes = 5 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.Bytes"]; + optional bytes NormalBytes = 6; + repeated uint64 MyUint64s = 7 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/neither/casttypepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/neither/casttypepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..90dd8cf50405adb57a06566da0e10dd011deddb6 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/neither/casttypepb_test.go @@ -0,0 +1,247 @@ +// Code generated by protoc-gen-gogo. +// source: combos/neither/casttype.proto +// DO NOT EDIT! + +/* +Package casttype is a generated protocol buffer package. + +It is generated from these files: + combos/neither/casttype.proto + +It has these top-level messages: + Castaway +*/ +package casttype + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestCastawayProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCastawayProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Castaway, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCastaway(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCastawayProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCastaway(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Castaway{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCastawayJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCastawayProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCastawayProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCasttypeDescription(t *testing.T) { + CasttypeDescription() +} +func TestCastawayVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCastawayFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCastawayGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCastawaySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCastawaySize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Castaway, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCastaway(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCastawayStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unmarshaler/casttype.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unmarshaler/casttype.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..8dca65d6c6be52972e3f8f0ccea30491bb6e996b --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unmarshaler/casttype.pb.go @@ -0,0 +1,2302 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unmarshaler/casttype.proto +// DO NOT EDIT! + +/* + Package casttype is a generated protocol buffer package. + + It is generated from these files: + combos/unmarshaler/casttype.proto + + It has these top-level messages: + Castaway +*/ +package casttype + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_casttype "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Castaway struct { + Int32Ptr *int32 `protobuf:"varint,1,opt,name=Int32Ptr,casttype=int32" json:"Int32Ptr,omitempty"` + Int32 int32 `protobuf:"varint,2,opt,name=Int32,casttype=int32" json:"Int32"` + MyUint64Ptr *github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,3,opt,name=MyUint64Ptr,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64Ptr,omitempty"` + MyUint64 github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,4,opt,name=MyUint64,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64"` + MyBytes github_com_gogo_protobuf_test_casttype.Bytes `protobuf:"bytes,5,opt,name=MyBytes,casttype=github.com/gogo/protobuf/test/casttype.Bytes" json:"MyBytes,omitempty"` + NormalBytes []byte `protobuf:"bytes,6,opt,name=NormalBytes" json:"NormalBytes,omitempty"` + MyUint64S []github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,7,rep,name=MyUint64s,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64s,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Castaway) Reset() { *m = Castaway{} } +func (*Castaway) ProtoMessage() {} + +func (this *Castaway) Description() (desc *google_protobuf.FileDescriptorSet) { + return CasttypeDescription() +} +func CasttypeDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unmarshaler/casttype.proto"), + Package: func(v string) *string { return &v }("casttype"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Castaway"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Int32Ptr"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x5, 0x69, 0x6e, 0x74, 0x33, 0x32})}}, + }, {Name: func(v string) *string { return &v }("Int32"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x5, 0x69, 0x6e, 0x74, 0x33, 0x32})}}, + }, {Name: func(v string) *string { return &v }("MyUint64Ptr"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("MyUint64"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("MyBytes"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }, {Name: func(v string) *string { return &v }("NormalBytes"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("MyUint64s"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (this *Castaway) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Castaway) + if !ok { + return fmt.Errorf("that is not of type *Castaway") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Castaway but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Castawaybut is not nil && this == nil") + } + if this.Int32Ptr != nil && that1.Int32Ptr != nil { + if *this.Int32Ptr != *that1.Int32Ptr { + return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", *this.Int32Ptr, *that1.Int32Ptr) + } + } else if this.Int32Ptr != nil { + return fmt.Errorf("this.Int32Ptr == nil && that.Int32Ptr != nil") + } else if that1.Int32Ptr != nil { + return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", this.Int32Ptr, that1.Int32Ptr) + } + if this.Int32 != that1.Int32 { + return fmt.Errorf("Int32 this(%v) Not Equal that(%v)", this.Int32, that1.Int32) + } + if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil { + if *this.MyUint64Ptr != *that1.MyUint64Ptr { + return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", *this.MyUint64Ptr, *that1.MyUint64Ptr) + } + } else if this.MyUint64Ptr != nil { + return fmt.Errorf("this.MyUint64Ptr == nil && that.MyUint64Ptr != nil") + } else if that1.MyUint64Ptr != nil { + return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", this.MyUint64Ptr, that1.MyUint64Ptr) + } + if this.MyUint64 != that1.MyUint64 { + return fmt.Errorf("MyUint64 this(%v) Not Equal that(%v)", this.MyUint64, that1.MyUint64) + } + if !bytes.Equal(this.MyBytes, that1.MyBytes) { + return fmt.Errorf("MyBytes this(%v) Not Equal that(%v)", this.MyBytes, that1.MyBytes) + } + if !bytes.Equal(this.NormalBytes, that1.NormalBytes) { + return fmt.Errorf("NormalBytes this(%v) Not Equal that(%v)", this.NormalBytes, that1.NormalBytes) + } + if len(this.MyUint64S) != len(that1.MyUint64S) { + return fmt.Errorf("MyUint64S this(%v) Not Equal that(%v)", len(this.MyUint64S), len(that1.MyUint64S)) + } + for i := range this.MyUint64S { + if this.MyUint64S[i] != that1.MyUint64S[i] { + return fmt.Errorf("MyUint64S this[%v](%v) Not Equal that[%v](%v)", i, this.MyUint64S[i], i, that1.MyUint64S[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Castaway) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Castaway) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Int32Ptr != nil && that1.Int32Ptr != nil { + if *this.Int32Ptr != *that1.Int32Ptr { + return false + } + } else if this.Int32Ptr != nil { + return false + } else if that1.Int32Ptr != nil { + return false + } + if this.Int32 != that1.Int32 { + return false + } + if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil { + if *this.MyUint64Ptr != *that1.MyUint64Ptr { + return false + } + } else if this.MyUint64Ptr != nil { + return false + } else if that1.MyUint64Ptr != nil { + return false + } + if this.MyUint64 != that1.MyUint64 { + return false + } + if !bytes.Equal(this.MyBytes, that1.MyBytes) { + return false + } + if !bytes.Equal(this.NormalBytes, that1.NormalBytes) { + return false + } + if len(this.MyUint64S) != len(that1.MyUint64S) { + return false + } + for i := range this.MyUint64S { + if this.MyUint64S[i] != that1.MyUint64S[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} + +type CastawayFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetInt32Ptr() *int32 + GetInt32() int32 + GetMyUint64Ptr() *github_com_gogo_protobuf_test_casttype.MyUint64Type + GetMyUint64() github_com_gogo_protobuf_test_casttype.MyUint64Type + GetMyBytes() github_com_gogo_protobuf_test_casttype.Bytes + GetNormalBytes() []byte + GetMyUint64S() []github_com_gogo_protobuf_test_casttype.MyUint64Type +} + +func (this *Castaway) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Castaway) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCastawayFromFace(this) +} + +func (this *Castaway) GetInt32Ptr() *int32 { + return this.Int32Ptr +} + +func (this *Castaway) GetInt32() int32 { + return this.Int32 +} + +func (this *Castaway) GetMyUint64Ptr() *github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64Ptr +} + +func (this *Castaway) GetMyUint64() github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64 +} + +func (this *Castaway) GetMyBytes() github_com_gogo_protobuf_test_casttype.Bytes { + return this.MyBytes +} + +func (this *Castaway) GetNormalBytes() []byte { + return this.NormalBytes +} + +func (this *Castaway) GetMyUint64S() []github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64S +} + +func NewCastawayFromFace(that CastawayFace) *Castaway { + this := &Castaway{} + this.Int32Ptr = that.GetInt32Ptr() + this.Int32 = that.GetInt32() + this.MyUint64Ptr = that.GetMyUint64Ptr() + this.MyUint64 = that.GetMyUint64() + this.MyBytes = that.GetMyBytes() + this.NormalBytes = that.GetNormalBytes() + this.MyUint64S = that.GetMyUint64S() + return this +} + +func (this *Castaway) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 11) + s = append(s, "&casttype.Castaway{") + if this.Int32Ptr != nil { + s = append(s, "Int32Ptr: "+valueToGoStringCasttype(this.Int32Ptr, "int32")+",\n") + } + s = append(s, "Int32: "+fmt.Sprintf("%#v", this.Int32)+",\n") + if this.MyUint64Ptr != nil { + s = append(s, "MyUint64Ptr: "+valueToGoStringCasttype(this.MyUint64Ptr, "github_com_gogo_protobuf_test_casttype.MyUint64Type")+",\n") + } + s = append(s, "MyUint64: "+fmt.Sprintf("%#v", this.MyUint64)+",\n") + if this.MyBytes != nil { + s = append(s, "MyBytes: "+valueToGoStringCasttype(this.MyBytes, "github_com_gogo_protobuf_test_casttype.Bytes")+",\n") + } + if this.NormalBytes != nil { + s = append(s, "NormalBytes: "+valueToGoStringCasttype(this.NormalBytes, "byte")+",\n") + } + if this.MyUint64S != nil { + s = append(s, "MyUint64S: "+fmt.Sprintf("%#v", this.MyUint64S)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringCasttype(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringCasttype(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedCastaway(r randyCasttype, easy bool) *Castaway { + this := &Castaway{} + if r.Intn(10) != 0 { + v1 := int32(r.Int63()) + if r.Intn(2) == 0 { + v1 *= -1 + } + this.Int32Ptr = &v1 + } + this.Int32 = int32(r.Int63()) + if r.Intn(2) == 0 { + this.Int32 *= -1 + } + if r.Intn(10) != 0 { + v2 := github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + this.MyUint64Ptr = &v2 + } + this.MyUint64 = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + if r.Intn(10) != 0 { + v3 := r.Intn(100) + this.MyBytes = make(github_com_gogo_protobuf_test_casttype.Bytes, v3) + for i := 0; i < v3; i++ { + this.MyBytes[i] = byte(r.Intn(256)) + } + } + if r.Intn(10) != 0 { + v4 := r.Intn(100) + this.NormalBytes = make([]byte, v4) + for i := 0; i < v4; i++ { + this.NormalBytes[i] = byte(r.Intn(256)) + } + } + if r.Intn(10) != 0 { + v5 := r.Intn(100) + this.MyUint64S = make([]github_com_gogo_protobuf_test_casttype.MyUint64Type, v5) + for i := 0; i < v5; i++ { + this.MyUint64S[i] = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedCasttype(r, 8) + } + return this +} + +type randyCasttype interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneCasttype(r randyCasttype) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringCasttype(r randyCasttype) string { + v6 := r.Intn(100) + tmps := make([]rune, v6) + for i := 0; i < v6; i++ { + tmps[i] = randUTF8RuneCasttype(r) + } + return string(tmps) +} +func randUnrecognizedCasttype(r randyCasttype, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldCasttype(data, r, fieldNumber, wire) + } + return data +} +func randFieldCasttype(data []byte, r randyCasttype, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateCasttype(data, uint64(key)) + v7 := r.Int63() + if r.Intn(2) == 0 { + v7 *= -1 + } + data = encodeVarintPopulateCasttype(data, uint64(v7)) + case 1: + data = encodeVarintPopulateCasttype(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateCasttype(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateCasttype(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateCasttype(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateCasttype(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Castaway) Size() (n int) { + var l int + _ = l + if m.Int32Ptr != nil { + n += 1 + sovCasttype(uint64(*m.Int32Ptr)) + } + n += 1 + sovCasttype(uint64(m.Int32)) + if m.MyUint64Ptr != nil { + n += 1 + sovCasttype(uint64(*m.MyUint64Ptr)) + } + n += 1 + sovCasttype(uint64(m.MyUint64)) + if m.MyBytes != nil { + l = len(m.MyBytes) + n += 1 + l + sovCasttype(uint64(l)) + } + if m.NormalBytes != nil { + l = len(m.NormalBytes) + n += 1 + l + sovCasttype(uint64(l)) + } + if len(m.MyUint64S) > 0 { + for _, e := range m.MyUint64S { + n += 1 + sovCasttype(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovCasttype(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozCasttype(x uint64) (n int) { + return sovCasttype(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Castaway) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Castaway{`, + `Int32Ptr:` + valueToStringCasttype(this.Int32Ptr) + `,`, + `Int32:` + fmt.Sprintf("%v", this.Int32) + `,`, + `MyUint64Ptr:` + valueToStringCasttype(this.MyUint64Ptr) + `,`, + `MyUint64:` + fmt.Sprintf("%v", this.MyUint64) + `,`, + `MyBytes:` + valueToStringCasttype(this.MyBytes) + `,`, + `NormalBytes:` + valueToStringCasttype(this.NormalBytes) + `,`, + `MyUint64S:` + fmt.Sprintf("%v", this.MyUint64S) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringCasttype(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Castaway) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttype + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Castaway: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Castaway: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32Ptr", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttype + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Int32Ptr = &v + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32", wireType) + } + m.Int32 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttype + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Int32 |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyUint64Ptr", wireType) + } + var v github_com_gogo_protobuf_test_casttype.MyUint64Type + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttype + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (github_com_gogo_protobuf_test_casttype.MyUint64Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MyUint64Ptr = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyUint64", wireType) + } + m.MyUint64 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttype + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.MyUint64 |= (github_com_gogo_protobuf_test_casttype.MyUint64Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MyBytes", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttype + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCasttype + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MyBytes = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NormalBytes", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttype + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCasttype + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NormalBytes = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyUint64S", wireType) + } + var v github_com_gogo_protobuf_test_casttype.MyUint64Type + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttype + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (github_com_gogo_protobuf_test_casttype.MyUint64Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MyUint64S = append(m.MyUint64S, v) + default: + iNdEx = preIndex + skippy, err := skipCasttype(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthCasttype + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipCasttype(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCasttype + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCasttype + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCasttype + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthCasttype + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCasttype + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipCasttype(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthCasttype = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowCasttype = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unmarshaler/casttype.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unmarshaler/casttype.proto new file mode 100644 index 0000000000000000000000000000000000000000..4c574e629b71d359bdd6fcc93e533e331b8f1da4 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unmarshaler/casttype.proto @@ -0,0 +1,66 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package casttype; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Castaway { + optional int64 Int32Ptr = 1 [(gogoproto.casttype) = "int32"]; + optional int64 Int32 = 2 [(gogoproto.nullable) = false, (gogoproto.casttype) = "int32"]; + optional uint64 MyUint64Ptr = 3 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + optional uint64 MyUint64 = 4 [(gogoproto.nullable) = false, (gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + optional bytes MyBytes = 5 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.Bytes"]; + optional bytes NormalBytes = 6; + repeated uint64 MyUint64s = 7 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unmarshaler/casttypepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unmarshaler/casttypepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..5a6b1361c5339dfc64d225462635353489b42c66 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unmarshaler/casttypepb_test.go @@ -0,0 +1,247 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unmarshaler/casttype.proto +// DO NOT EDIT! + +/* +Package casttype is a generated protocol buffer package. + +It is generated from these files: + combos/unmarshaler/casttype.proto + +It has these top-level messages: + Castaway +*/ +package casttype + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestCastawayProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCastawayProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Castaway, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCastaway(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCastawayProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCastaway(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Castaway{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCastawayJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCastawayProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCastawayProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCasttypeDescription(t *testing.T) { + CasttypeDescription() +} +func TestCastawayVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCastawayFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCastawayGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCastawaySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCastawaySize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Castaway, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCastaway(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCastawayStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeboth/casttype.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeboth/casttype.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..f8f59c924085b0f956ceb938ebdf8413a69ae7e8 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeboth/casttype.pb.go @@ -0,0 +1,2385 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeboth/casttype.proto +// DO NOT EDIT! + +/* + Package casttype is a generated protocol buffer package. + + It is generated from these files: + combos/unsafeboth/casttype.proto + + It has these top-level messages: + Castaway +*/ +package casttype + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_casttype "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Castaway struct { + Int32Ptr *int32 `protobuf:"varint,1,opt,name=Int32Ptr,casttype=int32" json:"Int32Ptr,omitempty"` + Int32 int32 `protobuf:"varint,2,opt,name=Int32,casttype=int32" json:"Int32"` + MyUint64Ptr *github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,3,opt,name=MyUint64Ptr,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64Ptr,omitempty"` + MyUint64 github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,4,opt,name=MyUint64,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64"` + MyBytes github_com_gogo_protobuf_test_casttype.Bytes `protobuf:"bytes,5,opt,name=MyBytes,casttype=github.com/gogo/protobuf/test/casttype.Bytes" json:"MyBytes,omitempty"` + NormalBytes []byte `protobuf:"bytes,6,opt,name=NormalBytes" json:"NormalBytes,omitempty"` + MyUint64S []github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,7,rep,name=MyUint64s,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64s,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Castaway) Reset() { *m = Castaway{} } +func (*Castaway) ProtoMessage() {} + +func (this *Castaway) Description() (desc *google_protobuf.FileDescriptorSet) { + return CasttypeDescription() +} +func CasttypeDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unsafeboth/casttype.proto"), + Package: func(v string) *string { return &v }("casttype"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Castaway"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Int32Ptr"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x5, 0x69, 0x6e, 0x74, 0x33, 0x32})}}, + }, {Name: func(v string) *string { return &v }("Int32"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x5, 0x69, 0x6e, 0x74, 0x33, 0x32})}}, + }, {Name: func(v string) *string { return &v }("MyUint64Ptr"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("MyUint64"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("MyBytes"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }, {Name: func(v string) *string { return &v }("NormalBytes"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("MyUint64s"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x1}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x1})}}, + }}, + } +} +func (this *Castaway) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Castaway) + if !ok { + return fmt.Errorf("that is not of type *Castaway") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Castaway but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Castawaybut is not nil && this == nil") + } + if this.Int32Ptr != nil && that1.Int32Ptr != nil { + if *this.Int32Ptr != *that1.Int32Ptr { + return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", *this.Int32Ptr, *that1.Int32Ptr) + } + } else if this.Int32Ptr != nil { + return fmt.Errorf("this.Int32Ptr == nil && that.Int32Ptr != nil") + } else if that1.Int32Ptr != nil { + return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", this.Int32Ptr, that1.Int32Ptr) + } + if this.Int32 != that1.Int32 { + return fmt.Errorf("Int32 this(%v) Not Equal that(%v)", this.Int32, that1.Int32) + } + if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil { + if *this.MyUint64Ptr != *that1.MyUint64Ptr { + return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", *this.MyUint64Ptr, *that1.MyUint64Ptr) + } + } else if this.MyUint64Ptr != nil { + return fmt.Errorf("this.MyUint64Ptr == nil && that.MyUint64Ptr != nil") + } else if that1.MyUint64Ptr != nil { + return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", this.MyUint64Ptr, that1.MyUint64Ptr) + } + if this.MyUint64 != that1.MyUint64 { + return fmt.Errorf("MyUint64 this(%v) Not Equal that(%v)", this.MyUint64, that1.MyUint64) + } + if !bytes.Equal(this.MyBytes, that1.MyBytes) { + return fmt.Errorf("MyBytes this(%v) Not Equal that(%v)", this.MyBytes, that1.MyBytes) + } + if !bytes.Equal(this.NormalBytes, that1.NormalBytes) { + return fmt.Errorf("NormalBytes this(%v) Not Equal that(%v)", this.NormalBytes, that1.NormalBytes) + } + if len(this.MyUint64S) != len(that1.MyUint64S) { + return fmt.Errorf("MyUint64S this(%v) Not Equal that(%v)", len(this.MyUint64S), len(that1.MyUint64S)) + } + for i := range this.MyUint64S { + if this.MyUint64S[i] != that1.MyUint64S[i] { + return fmt.Errorf("MyUint64S this[%v](%v) Not Equal that[%v](%v)", i, this.MyUint64S[i], i, that1.MyUint64S[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Castaway) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Castaway) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Int32Ptr != nil && that1.Int32Ptr != nil { + if *this.Int32Ptr != *that1.Int32Ptr { + return false + } + } else if this.Int32Ptr != nil { + return false + } else if that1.Int32Ptr != nil { + return false + } + if this.Int32 != that1.Int32 { + return false + } + if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil { + if *this.MyUint64Ptr != *that1.MyUint64Ptr { + return false + } + } else if this.MyUint64Ptr != nil { + return false + } else if that1.MyUint64Ptr != nil { + return false + } + if this.MyUint64 != that1.MyUint64 { + return false + } + if !bytes.Equal(this.MyBytes, that1.MyBytes) { + return false + } + if !bytes.Equal(this.NormalBytes, that1.NormalBytes) { + return false + } + if len(this.MyUint64S) != len(that1.MyUint64S) { + return false + } + for i := range this.MyUint64S { + if this.MyUint64S[i] != that1.MyUint64S[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} + +type CastawayFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetInt32Ptr() *int32 + GetInt32() int32 + GetMyUint64Ptr() *github_com_gogo_protobuf_test_casttype.MyUint64Type + GetMyUint64() github_com_gogo_protobuf_test_casttype.MyUint64Type + GetMyBytes() github_com_gogo_protobuf_test_casttype.Bytes + GetNormalBytes() []byte + GetMyUint64S() []github_com_gogo_protobuf_test_casttype.MyUint64Type +} + +func (this *Castaway) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Castaway) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCastawayFromFace(this) +} + +func (this *Castaway) GetInt32Ptr() *int32 { + return this.Int32Ptr +} + +func (this *Castaway) GetInt32() int32 { + return this.Int32 +} + +func (this *Castaway) GetMyUint64Ptr() *github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64Ptr +} + +func (this *Castaway) GetMyUint64() github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64 +} + +func (this *Castaway) GetMyBytes() github_com_gogo_protobuf_test_casttype.Bytes { + return this.MyBytes +} + +func (this *Castaway) GetNormalBytes() []byte { + return this.NormalBytes +} + +func (this *Castaway) GetMyUint64S() []github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64S +} + +func NewCastawayFromFace(that CastawayFace) *Castaway { + this := &Castaway{} + this.Int32Ptr = that.GetInt32Ptr() + this.Int32 = that.GetInt32() + this.MyUint64Ptr = that.GetMyUint64Ptr() + this.MyUint64 = that.GetMyUint64() + this.MyBytes = that.GetMyBytes() + this.NormalBytes = that.GetNormalBytes() + this.MyUint64S = that.GetMyUint64S() + return this +} + +func (this *Castaway) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 11) + s = append(s, "&casttype.Castaway{") + if this.Int32Ptr != nil { + s = append(s, "Int32Ptr: "+valueToGoStringCasttype(this.Int32Ptr, "int32")+",\n") + } + s = append(s, "Int32: "+fmt.Sprintf("%#v", this.Int32)+",\n") + if this.MyUint64Ptr != nil { + s = append(s, "MyUint64Ptr: "+valueToGoStringCasttype(this.MyUint64Ptr, "github_com_gogo_protobuf_test_casttype.MyUint64Type")+",\n") + } + s = append(s, "MyUint64: "+fmt.Sprintf("%#v", this.MyUint64)+",\n") + if this.MyBytes != nil { + s = append(s, "MyBytes: "+valueToGoStringCasttype(this.MyBytes, "github_com_gogo_protobuf_test_casttype.Bytes")+",\n") + } + if this.NormalBytes != nil { + s = append(s, "NormalBytes: "+valueToGoStringCasttype(this.NormalBytes, "byte")+",\n") + } + if this.MyUint64S != nil { + s = append(s, "MyUint64S: "+fmt.Sprintf("%#v", this.MyUint64S)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringCasttype(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringCasttype(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedCastaway(r randyCasttype, easy bool) *Castaway { + this := &Castaway{} + if r.Intn(10) != 0 { + v1 := int32(r.Int63()) + if r.Intn(2) == 0 { + v1 *= -1 + } + this.Int32Ptr = &v1 + } + this.Int32 = int32(r.Int63()) + if r.Intn(2) == 0 { + this.Int32 *= -1 + } + if r.Intn(10) != 0 { + v2 := github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + this.MyUint64Ptr = &v2 + } + this.MyUint64 = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + if r.Intn(10) != 0 { + v3 := r.Intn(100) + this.MyBytes = make(github_com_gogo_protobuf_test_casttype.Bytes, v3) + for i := 0; i < v3; i++ { + this.MyBytes[i] = byte(r.Intn(256)) + } + } + if r.Intn(10) != 0 { + v4 := r.Intn(100) + this.NormalBytes = make([]byte, v4) + for i := 0; i < v4; i++ { + this.NormalBytes[i] = byte(r.Intn(256)) + } + } + if r.Intn(10) != 0 { + v5 := r.Intn(100) + this.MyUint64S = make([]github_com_gogo_protobuf_test_casttype.MyUint64Type, v5) + for i := 0; i < v5; i++ { + this.MyUint64S[i] = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedCasttype(r, 8) + } + return this +} + +type randyCasttype interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneCasttype(r randyCasttype) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringCasttype(r randyCasttype) string { + v6 := r.Intn(100) + tmps := make([]rune, v6) + for i := 0; i < v6; i++ { + tmps[i] = randUTF8RuneCasttype(r) + } + return string(tmps) +} +func randUnrecognizedCasttype(r randyCasttype, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldCasttype(data, r, fieldNumber, wire) + } + return data +} +func randFieldCasttype(data []byte, r randyCasttype, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateCasttype(data, uint64(key)) + v7 := r.Int63() + if r.Intn(2) == 0 { + v7 *= -1 + } + data = encodeVarintPopulateCasttype(data, uint64(v7)) + case 1: + data = encodeVarintPopulateCasttype(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateCasttype(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateCasttype(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateCasttype(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateCasttype(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Castaway) Size() (n int) { + var l int + _ = l + if m.Int32Ptr != nil { + n += 1 + sovCasttype(uint64(*m.Int32Ptr)) + } + n += 1 + sovCasttype(uint64(m.Int32)) + if m.MyUint64Ptr != nil { + n += 1 + sovCasttype(uint64(*m.MyUint64Ptr)) + } + n += 1 + sovCasttype(uint64(m.MyUint64)) + if m.MyBytes != nil { + l = len(m.MyBytes) + n += 1 + l + sovCasttype(uint64(l)) + } + if m.NormalBytes != nil { + l = len(m.NormalBytes) + n += 1 + l + sovCasttype(uint64(l)) + } + if len(m.MyUint64S) > 0 { + for _, e := range m.MyUint64S { + n += 1 + sovCasttype(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovCasttype(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozCasttype(x uint64) (n int) { + return sovCasttype(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Castaway) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Castaway{`, + `Int32Ptr:` + valueToStringCasttype(this.Int32Ptr) + `,`, + `Int32:` + fmt.Sprintf("%v", this.Int32) + `,`, + `MyUint64Ptr:` + valueToStringCasttype(this.MyUint64Ptr) + `,`, + `MyUint64:` + fmt.Sprintf("%v", this.MyUint64) + `,`, + `MyBytes:` + valueToStringCasttype(this.MyBytes) + `,`, + `NormalBytes:` + valueToStringCasttype(this.NormalBytes) + `,`, + `MyUint64S:` + fmt.Sprintf("%v", this.MyUint64S) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringCasttype(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Castaway) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Castaway) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Int32Ptr != nil { + data[i] = 0x8 + i++ + i = encodeVarintCasttype(data, i, uint64(*m.Int32Ptr)) + } + data[i] = 0x10 + i++ + i = encodeVarintCasttype(data, i, uint64(m.Int32)) + if m.MyUint64Ptr != nil { + data[i] = 0x18 + i++ + i = encodeVarintCasttype(data, i, uint64(*m.MyUint64Ptr)) + } + data[i] = 0x20 + i++ + i = encodeVarintCasttype(data, i, uint64(m.MyUint64)) + if m.MyBytes != nil { + data[i] = 0x2a + i++ + i = encodeVarintCasttype(data, i, uint64(len(m.MyBytes))) + i += copy(data[i:], m.MyBytes) + } + if m.NormalBytes != nil { + data[i] = 0x32 + i++ + i = encodeVarintCasttype(data, i, uint64(len(m.NormalBytes))) + i += copy(data[i:], m.NormalBytes) + } + if len(m.MyUint64S) > 0 { + for _, num := range m.MyUint64S { + data[i] = 0x38 + i++ + i = encodeVarintCasttype(data, i, uint64(num)) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Casttype(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Casttype(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintCasttype(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *Castaway) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Castaway: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Castaway: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32Ptr", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Int32Ptr = &v + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32", wireType) + } + m.Int32 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Int32 |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyUint64Ptr", wireType) + } + var v github_com_gogo_protobuf_test_casttype.MyUint64Type + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (github_com_gogo_protobuf_test_casttype.MyUint64Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MyUint64Ptr = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyUint64", wireType) + } + m.MyUint64 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.MyUint64 |= (github_com_gogo_protobuf_test_casttype.MyUint64Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MyBytes", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCasttypeUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MyBytes = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NormalBytes", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCasttypeUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NormalBytes = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyUint64S", wireType) + } + var v github_com_gogo_protobuf_test_casttype.MyUint64Type + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (github_com_gogo_protobuf_test_casttype.MyUint64Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MyUint64S = append(m.MyUint64S, v) + default: + iNdEx = preIndex + skippy, err := skipCasttypeUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthCasttypeUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipCasttypeUnsafe(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthCasttypeUnsafe + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipCasttypeUnsafe(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthCasttypeUnsafe = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowCasttypeUnsafe = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeboth/casttype.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeboth/casttype.proto new file mode 100644 index 0000000000000000000000000000000000000000..8d1e24ad97b4873f59bd67e3dc6d6002c76593fa --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeboth/casttype.proto @@ -0,0 +1,66 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package casttype; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = true; +option (gogoproto.unsafe_unmarshaler_all) = true; + +message Castaway { + optional int64 Int32Ptr = 1 [(gogoproto.casttype) = "int32"]; + optional int64 Int32 = 2 [(gogoproto.nullable) = false, (gogoproto.casttype) = "int32"]; + optional uint64 MyUint64Ptr = 3 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + optional uint64 MyUint64 = 4 [(gogoproto.nullable) = false, (gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + optional bytes MyBytes = 5 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.Bytes"]; + optional bytes NormalBytes = 6; + repeated uint64 MyUint64s = 7 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeboth/casttypepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeboth/casttypepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..eccc31d471742603124b57b9044bc9cc40ed7fdd --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeboth/casttypepb_test.go @@ -0,0 +1,275 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeboth/casttype.proto +// DO NOT EDIT! + +/* +Package casttype is a generated protocol buffer package. + +It is generated from these files: + combos/unsafeboth/casttype.proto + +It has these top-level messages: + Castaway +*/ +package casttype + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestCastawayProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCastawayMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCastawayProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Castaway, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCastaway(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCastawayProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCastaway(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Castaway{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCastawayJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCastawayProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCastawayProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCasttypeDescription(t *testing.T) { + CasttypeDescription() +} +func TestCastawayVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCastawayFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCastawayGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCastawaySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCastawaySize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Castaway, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCastaway(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCastawayStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafemarshaler/casttype.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafemarshaler/casttype.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..156cdbe3090609e72c2908ccbca1a645693b7f14 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafemarshaler/casttype.pb.go @@ -0,0 +1,2074 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafemarshaler/casttype.proto +// DO NOT EDIT! + +/* +Package casttype is a generated protocol buffer package. + +It is generated from these files: + combos/unsafemarshaler/casttype.proto + +It has these top-level messages: + Castaway +*/ +package casttype + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_casttype "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Castaway struct { + Int32Ptr *int32 `protobuf:"varint,1,opt,name=Int32Ptr,casttype=int32" json:"Int32Ptr,omitempty"` + Int32 int32 `protobuf:"varint,2,opt,name=Int32,casttype=int32" json:"Int32"` + MyUint64Ptr *github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,3,opt,name=MyUint64Ptr,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64Ptr,omitempty"` + MyUint64 github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,4,opt,name=MyUint64,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64"` + MyBytes github_com_gogo_protobuf_test_casttype.Bytes `protobuf:"bytes,5,opt,name=MyBytes,casttype=github.com/gogo/protobuf/test/casttype.Bytes" json:"MyBytes,omitempty"` + NormalBytes []byte `protobuf:"bytes,6,opt,name=NormalBytes" json:"NormalBytes,omitempty"` + MyUint64S []github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,7,rep,name=MyUint64s,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64s,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Castaway) Reset() { *m = Castaway{} } +func (*Castaway) ProtoMessage() {} + +func (this *Castaway) Description() (desc *google_protobuf.FileDescriptorSet) { + return CasttypeDescription() +} +func CasttypeDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unsafemarshaler/casttype.proto"), + Package: func(v string) *string { return &v }("casttype"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Castaway"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Int32Ptr"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x5, 0x69, 0x6e, 0x74, 0x33, 0x32})}}, + }, {Name: func(v string) *string { return &v }("Int32"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x5, 0x69, 0x6e, 0x74, 0x33, 0x32})}}, + }, {Name: func(v string) *string { return &v }("MyUint64Ptr"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("MyUint64"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("MyBytes"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }, {Name: func(v string) *string { return &v }("NormalBytes"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("MyUint64s"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x1}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (this *Castaway) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Castaway) + if !ok { + return fmt.Errorf("that is not of type *Castaway") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Castaway but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Castawaybut is not nil && this == nil") + } + if this.Int32Ptr != nil && that1.Int32Ptr != nil { + if *this.Int32Ptr != *that1.Int32Ptr { + return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", *this.Int32Ptr, *that1.Int32Ptr) + } + } else if this.Int32Ptr != nil { + return fmt.Errorf("this.Int32Ptr == nil && that.Int32Ptr != nil") + } else if that1.Int32Ptr != nil { + return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", this.Int32Ptr, that1.Int32Ptr) + } + if this.Int32 != that1.Int32 { + return fmt.Errorf("Int32 this(%v) Not Equal that(%v)", this.Int32, that1.Int32) + } + if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil { + if *this.MyUint64Ptr != *that1.MyUint64Ptr { + return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", *this.MyUint64Ptr, *that1.MyUint64Ptr) + } + } else if this.MyUint64Ptr != nil { + return fmt.Errorf("this.MyUint64Ptr == nil && that.MyUint64Ptr != nil") + } else if that1.MyUint64Ptr != nil { + return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", this.MyUint64Ptr, that1.MyUint64Ptr) + } + if this.MyUint64 != that1.MyUint64 { + return fmt.Errorf("MyUint64 this(%v) Not Equal that(%v)", this.MyUint64, that1.MyUint64) + } + if !bytes.Equal(this.MyBytes, that1.MyBytes) { + return fmt.Errorf("MyBytes this(%v) Not Equal that(%v)", this.MyBytes, that1.MyBytes) + } + if !bytes.Equal(this.NormalBytes, that1.NormalBytes) { + return fmt.Errorf("NormalBytes this(%v) Not Equal that(%v)", this.NormalBytes, that1.NormalBytes) + } + if len(this.MyUint64S) != len(that1.MyUint64S) { + return fmt.Errorf("MyUint64S this(%v) Not Equal that(%v)", len(this.MyUint64S), len(that1.MyUint64S)) + } + for i := range this.MyUint64S { + if this.MyUint64S[i] != that1.MyUint64S[i] { + return fmt.Errorf("MyUint64S this[%v](%v) Not Equal that[%v](%v)", i, this.MyUint64S[i], i, that1.MyUint64S[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Castaway) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Castaway) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Int32Ptr != nil && that1.Int32Ptr != nil { + if *this.Int32Ptr != *that1.Int32Ptr { + return false + } + } else if this.Int32Ptr != nil { + return false + } else if that1.Int32Ptr != nil { + return false + } + if this.Int32 != that1.Int32 { + return false + } + if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil { + if *this.MyUint64Ptr != *that1.MyUint64Ptr { + return false + } + } else if this.MyUint64Ptr != nil { + return false + } else if that1.MyUint64Ptr != nil { + return false + } + if this.MyUint64 != that1.MyUint64 { + return false + } + if !bytes.Equal(this.MyBytes, that1.MyBytes) { + return false + } + if !bytes.Equal(this.NormalBytes, that1.NormalBytes) { + return false + } + if len(this.MyUint64S) != len(that1.MyUint64S) { + return false + } + for i := range this.MyUint64S { + if this.MyUint64S[i] != that1.MyUint64S[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} + +type CastawayFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetInt32Ptr() *int32 + GetInt32() int32 + GetMyUint64Ptr() *github_com_gogo_protobuf_test_casttype.MyUint64Type + GetMyUint64() github_com_gogo_protobuf_test_casttype.MyUint64Type + GetMyBytes() github_com_gogo_protobuf_test_casttype.Bytes + GetNormalBytes() []byte + GetMyUint64S() []github_com_gogo_protobuf_test_casttype.MyUint64Type +} + +func (this *Castaway) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Castaway) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCastawayFromFace(this) +} + +func (this *Castaway) GetInt32Ptr() *int32 { + return this.Int32Ptr +} + +func (this *Castaway) GetInt32() int32 { + return this.Int32 +} + +func (this *Castaway) GetMyUint64Ptr() *github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64Ptr +} + +func (this *Castaway) GetMyUint64() github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64 +} + +func (this *Castaway) GetMyBytes() github_com_gogo_protobuf_test_casttype.Bytes { + return this.MyBytes +} + +func (this *Castaway) GetNormalBytes() []byte { + return this.NormalBytes +} + +func (this *Castaway) GetMyUint64S() []github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64S +} + +func NewCastawayFromFace(that CastawayFace) *Castaway { + this := &Castaway{} + this.Int32Ptr = that.GetInt32Ptr() + this.Int32 = that.GetInt32() + this.MyUint64Ptr = that.GetMyUint64Ptr() + this.MyUint64 = that.GetMyUint64() + this.MyBytes = that.GetMyBytes() + this.NormalBytes = that.GetNormalBytes() + this.MyUint64S = that.GetMyUint64S() + return this +} + +func (this *Castaway) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 11) + s = append(s, "&casttype.Castaway{") + if this.Int32Ptr != nil { + s = append(s, "Int32Ptr: "+valueToGoStringCasttype(this.Int32Ptr, "int32")+",\n") + } + s = append(s, "Int32: "+fmt.Sprintf("%#v", this.Int32)+",\n") + if this.MyUint64Ptr != nil { + s = append(s, "MyUint64Ptr: "+valueToGoStringCasttype(this.MyUint64Ptr, "github_com_gogo_protobuf_test_casttype.MyUint64Type")+",\n") + } + s = append(s, "MyUint64: "+fmt.Sprintf("%#v", this.MyUint64)+",\n") + if this.MyBytes != nil { + s = append(s, "MyBytes: "+valueToGoStringCasttype(this.MyBytes, "github_com_gogo_protobuf_test_casttype.Bytes")+",\n") + } + if this.NormalBytes != nil { + s = append(s, "NormalBytes: "+valueToGoStringCasttype(this.NormalBytes, "byte")+",\n") + } + if this.MyUint64S != nil { + s = append(s, "MyUint64S: "+fmt.Sprintf("%#v", this.MyUint64S)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringCasttype(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringCasttype(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedCastaway(r randyCasttype, easy bool) *Castaway { + this := &Castaway{} + if r.Intn(10) != 0 { + v1 := int32(r.Int63()) + if r.Intn(2) == 0 { + v1 *= -1 + } + this.Int32Ptr = &v1 + } + this.Int32 = int32(r.Int63()) + if r.Intn(2) == 0 { + this.Int32 *= -1 + } + if r.Intn(10) != 0 { + v2 := github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + this.MyUint64Ptr = &v2 + } + this.MyUint64 = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + if r.Intn(10) != 0 { + v3 := r.Intn(100) + this.MyBytes = make(github_com_gogo_protobuf_test_casttype.Bytes, v3) + for i := 0; i < v3; i++ { + this.MyBytes[i] = byte(r.Intn(256)) + } + } + if r.Intn(10) != 0 { + v4 := r.Intn(100) + this.NormalBytes = make([]byte, v4) + for i := 0; i < v4; i++ { + this.NormalBytes[i] = byte(r.Intn(256)) + } + } + if r.Intn(10) != 0 { + v5 := r.Intn(100) + this.MyUint64S = make([]github_com_gogo_protobuf_test_casttype.MyUint64Type, v5) + for i := 0; i < v5; i++ { + this.MyUint64S[i] = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedCasttype(r, 8) + } + return this +} + +type randyCasttype interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneCasttype(r randyCasttype) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringCasttype(r randyCasttype) string { + v6 := r.Intn(100) + tmps := make([]rune, v6) + for i := 0; i < v6; i++ { + tmps[i] = randUTF8RuneCasttype(r) + } + return string(tmps) +} +func randUnrecognizedCasttype(r randyCasttype, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldCasttype(data, r, fieldNumber, wire) + } + return data +} +func randFieldCasttype(data []byte, r randyCasttype, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateCasttype(data, uint64(key)) + v7 := r.Int63() + if r.Intn(2) == 0 { + v7 *= -1 + } + data = encodeVarintPopulateCasttype(data, uint64(v7)) + case 1: + data = encodeVarintPopulateCasttype(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateCasttype(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateCasttype(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateCasttype(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateCasttype(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Castaway) Size() (n int) { + var l int + _ = l + if m.Int32Ptr != nil { + n += 1 + sovCasttype(uint64(*m.Int32Ptr)) + } + n += 1 + sovCasttype(uint64(m.Int32)) + if m.MyUint64Ptr != nil { + n += 1 + sovCasttype(uint64(*m.MyUint64Ptr)) + } + n += 1 + sovCasttype(uint64(m.MyUint64)) + if m.MyBytes != nil { + l = len(m.MyBytes) + n += 1 + l + sovCasttype(uint64(l)) + } + if m.NormalBytes != nil { + l = len(m.NormalBytes) + n += 1 + l + sovCasttype(uint64(l)) + } + if len(m.MyUint64S) > 0 { + for _, e := range m.MyUint64S { + n += 1 + sovCasttype(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovCasttype(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozCasttype(x uint64) (n int) { + return sovCasttype(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Castaway) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Castaway{`, + `Int32Ptr:` + valueToStringCasttype(this.Int32Ptr) + `,`, + `Int32:` + fmt.Sprintf("%v", this.Int32) + `,`, + `MyUint64Ptr:` + valueToStringCasttype(this.MyUint64Ptr) + `,`, + `MyUint64:` + fmt.Sprintf("%v", this.MyUint64) + `,`, + `MyBytes:` + valueToStringCasttype(this.MyBytes) + `,`, + `NormalBytes:` + valueToStringCasttype(this.NormalBytes) + `,`, + `MyUint64S:` + fmt.Sprintf("%v", this.MyUint64S) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringCasttype(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Castaway) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Castaway) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Int32Ptr != nil { + data[i] = 0x8 + i++ + i = encodeVarintCasttype(data, i, uint64(*m.Int32Ptr)) + } + data[i] = 0x10 + i++ + i = encodeVarintCasttype(data, i, uint64(m.Int32)) + if m.MyUint64Ptr != nil { + data[i] = 0x18 + i++ + i = encodeVarintCasttype(data, i, uint64(*m.MyUint64Ptr)) + } + data[i] = 0x20 + i++ + i = encodeVarintCasttype(data, i, uint64(m.MyUint64)) + if m.MyBytes != nil { + data[i] = 0x2a + i++ + i = encodeVarintCasttype(data, i, uint64(len(m.MyBytes))) + i += copy(data[i:], m.MyBytes) + } + if m.NormalBytes != nil { + data[i] = 0x32 + i++ + i = encodeVarintCasttype(data, i, uint64(len(m.NormalBytes))) + i += copy(data[i:], m.NormalBytes) + } + if len(m.MyUint64S) > 0 { + for _, num := range m.MyUint64S { + data[i] = 0x38 + i++ + i = encodeVarintCasttype(data, i, uint64(num)) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Casttype(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Casttype(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintCasttype(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafemarshaler/casttype.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafemarshaler/casttype.proto new file mode 100644 index 0000000000000000000000000000000000000000..c7b7599e3dc797da2e9efdf60a883f031d60a81c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafemarshaler/casttype.proto @@ -0,0 +1,66 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package casttype; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = true; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Castaway { + optional int64 Int32Ptr = 1 [(gogoproto.casttype) = "int32"]; + optional int64 Int32 = 2 [(gogoproto.nullable) = false, (gogoproto.casttype) = "int32"]; + optional uint64 MyUint64Ptr = 3 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + optional uint64 MyUint64 = 4 [(gogoproto.nullable) = false, (gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + optional bytes MyBytes = 5 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.Bytes"]; + optional bytes NormalBytes = 6; + repeated uint64 MyUint64s = 7 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafemarshaler/casttypepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafemarshaler/casttypepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..77dc137a925905c087ed23ec633440d87c882aea --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafemarshaler/casttypepb_test.go @@ -0,0 +1,275 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafemarshaler/casttype.proto +// DO NOT EDIT! + +/* +Package casttype is a generated protocol buffer package. + +It is generated from these files: + combos/unsafemarshaler/casttype.proto + +It has these top-level messages: + Castaway +*/ +package casttype + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestCastawayProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCastawayMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCastawayProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Castaway, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCastaway(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCastawayProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCastaway(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Castaway{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCastawayJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCastawayProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCastawayProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCasttypeDescription(t *testing.T) { + CasttypeDescription() +} +func TestCastawayVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCastawayFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCastawayGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCastawaySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCastawaySize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Castaway, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCastaway(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCastawayStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeunmarshaler/casttype.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeunmarshaler/casttype.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..205d91a7d1ed84530f7c4563bd8bfee0a1fc23bd --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeunmarshaler/casttype.pb.go @@ -0,0 +1,2302 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeunmarshaler/casttype.proto +// DO NOT EDIT! + +/* + Package casttype is a generated protocol buffer package. + + It is generated from these files: + combos/unsafeunmarshaler/casttype.proto + + It has these top-level messages: + Castaway +*/ +package casttype + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_casttype "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Castaway struct { + Int32Ptr *int32 `protobuf:"varint,1,opt,name=Int32Ptr,casttype=int32" json:"Int32Ptr,omitempty"` + Int32 int32 `protobuf:"varint,2,opt,name=Int32,casttype=int32" json:"Int32"` + MyUint64Ptr *github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,3,opt,name=MyUint64Ptr,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64Ptr,omitempty"` + MyUint64 github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,4,opt,name=MyUint64,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64"` + MyBytes github_com_gogo_protobuf_test_casttype.Bytes `protobuf:"bytes,5,opt,name=MyBytes,casttype=github.com/gogo/protobuf/test/casttype.Bytes" json:"MyBytes,omitempty"` + NormalBytes []byte `protobuf:"bytes,6,opt,name=NormalBytes" json:"NormalBytes,omitempty"` + MyUint64S []github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,7,rep,name=MyUint64s,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type" json:"MyUint64s,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Castaway) Reset() { *m = Castaway{} } +func (*Castaway) ProtoMessage() {} + +func (this *Castaway) Description() (desc *google_protobuf.FileDescriptorSet) { + return CasttypeDescription() +} +func CasttypeDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unsafeunmarshaler/casttype.proto"), + Package: func(v string) *string { return &v }("casttype"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Castaway"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Int32Ptr"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x5, 0x69, 0x6e, 0x74, 0x33, 0x32})}}, + }, {Name: func(v string) *string { return &v }("Int32"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x5, 0x69, 0x6e, 0x74, 0x33, 0x32})}}, + }, {Name: func(v string) *string { return &v }("MyUint64Ptr"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("MyUint64"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("MyBytes"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }, {Name: func(v string) *string { return &v }("NormalBytes"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("MyUint64s"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x1})}}, + }}, + } +} +func (this *Castaway) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Castaway) + if !ok { + return fmt.Errorf("that is not of type *Castaway") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Castaway but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Castawaybut is not nil && this == nil") + } + if this.Int32Ptr != nil && that1.Int32Ptr != nil { + if *this.Int32Ptr != *that1.Int32Ptr { + return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", *this.Int32Ptr, *that1.Int32Ptr) + } + } else if this.Int32Ptr != nil { + return fmt.Errorf("this.Int32Ptr == nil && that.Int32Ptr != nil") + } else if that1.Int32Ptr != nil { + return fmt.Errorf("Int32Ptr this(%v) Not Equal that(%v)", this.Int32Ptr, that1.Int32Ptr) + } + if this.Int32 != that1.Int32 { + return fmt.Errorf("Int32 this(%v) Not Equal that(%v)", this.Int32, that1.Int32) + } + if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil { + if *this.MyUint64Ptr != *that1.MyUint64Ptr { + return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", *this.MyUint64Ptr, *that1.MyUint64Ptr) + } + } else if this.MyUint64Ptr != nil { + return fmt.Errorf("this.MyUint64Ptr == nil && that.MyUint64Ptr != nil") + } else if that1.MyUint64Ptr != nil { + return fmt.Errorf("MyUint64Ptr this(%v) Not Equal that(%v)", this.MyUint64Ptr, that1.MyUint64Ptr) + } + if this.MyUint64 != that1.MyUint64 { + return fmt.Errorf("MyUint64 this(%v) Not Equal that(%v)", this.MyUint64, that1.MyUint64) + } + if !bytes.Equal(this.MyBytes, that1.MyBytes) { + return fmt.Errorf("MyBytes this(%v) Not Equal that(%v)", this.MyBytes, that1.MyBytes) + } + if !bytes.Equal(this.NormalBytes, that1.NormalBytes) { + return fmt.Errorf("NormalBytes this(%v) Not Equal that(%v)", this.NormalBytes, that1.NormalBytes) + } + if len(this.MyUint64S) != len(that1.MyUint64S) { + return fmt.Errorf("MyUint64S this(%v) Not Equal that(%v)", len(this.MyUint64S), len(that1.MyUint64S)) + } + for i := range this.MyUint64S { + if this.MyUint64S[i] != that1.MyUint64S[i] { + return fmt.Errorf("MyUint64S this[%v](%v) Not Equal that[%v](%v)", i, this.MyUint64S[i], i, that1.MyUint64S[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Castaway) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Castaway) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Int32Ptr != nil && that1.Int32Ptr != nil { + if *this.Int32Ptr != *that1.Int32Ptr { + return false + } + } else if this.Int32Ptr != nil { + return false + } else if that1.Int32Ptr != nil { + return false + } + if this.Int32 != that1.Int32 { + return false + } + if this.MyUint64Ptr != nil && that1.MyUint64Ptr != nil { + if *this.MyUint64Ptr != *that1.MyUint64Ptr { + return false + } + } else if this.MyUint64Ptr != nil { + return false + } else if that1.MyUint64Ptr != nil { + return false + } + if this.MyUint64 != that1.MyUint64 { + return false + } + if !bytes.Equal(this.MyBytes, that1.MyBytes) { + return false + } + if !bytes.Equal(this.NormalBytes, that1.NormalBytes) { + return false + } + if len(this.MyUint64S) != len(that1.MyUint64S) { + return false + } + for i := range this.MyUint64S { + if this.MyUint64S[i] != that1.MyUint64S[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} + +type CastawayFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetInt32Ptr() *int32 + GetInt32() int32 + GetMyUint64Ptr() *github_com_gogo_protobuf_test_casttype.MyUint64Type + GetMyUint64() github_com_gogo_protobuf_test_casttype.MyUint64Type + GetMyBytes() github_com_gogo_protobuf_test_casttype.Bytes + GetNormalBytes() []byte + GetMyUint64S() []github_com_gogo_protobuf_test_casttype.MyUint64Type +} + +func (this *Castaway) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Castaway) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCastawayFromFace(this) +} + +func (this *Castaway) GetInt32Ptr() *int32 { + return this.Int32Ptr +} + +func (this *Castaway) GetInt32() int32 { + return this.Int32 +} + +func (this *Castaway) GetMyUint64Ptr() *github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64Ptr +} + +func (this *Castaway) GetMyUint64() github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64 +} + +func (this *Castaway) GetMyBytes() github_com_gogo_protobuf_test_casttype.Bytes { + return this.MyBytes +} + +func (this *Castaway) GetNormalBytes() []byte { + return this.NormalBytes +} + +func (this *Castaway) GetMyUint64S() []github_com_gogo_protobuf_test_casttype.MyUint64Type { + return this.MyUint64S +} + +func NewCastawayFromFace(that CastawayFace) *Castaway { + this := &Castaway{} + this.Int32Ptr = that.GetInt32Ptr() + this.Int32 = that.GetInt32() + this.MyUint64Ptr = that.GetMyUint64Ptr() + this.MyUint64 = that.GetMyUint64() + this.MyBytes = that.GetMyBytes() + this.NormalBytes = that.GetNormalBytes() + this.MyUint64S = that.GetMyUint64S() + return this +} + +func (this *Castaway) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 11) + s = append(s, "&casttype.Castaway{") + if this.Int32Ptr != nil { + s = append(s, "Int32Ptr: "+valueToGoStringCasttype(this.Int32Ptr, "int32")+",\n") + } + s = append(s, "Int32: "+fmt.Sprintf("%#v", this.Int32)+",\n") + if this.MyUint64Ptr != nil { + s = append(s, "MyUint64Ptr: "+valueToGoStringCasttype(this.MyUint64Ptr, "github_com_gogo_protobuf_test_casttype.MyUint64Type")+",\n") + } + s = append(s, "MyUint64: "+fmt.Sprintf("%#v", this.MyUint64)+",\n") + if this.MyBytes != nil { + s = append(s, "MyBytes: "+valueToGoStringCasttype(this.MyBytes, "github_com_gogo_protobuf_test_casttype.Bytes")+",\n") + } + if this.NormalBytes != nil { + s = append(s, "NormalBytes: "+valueToGoStringCasttype(this.NormalBytes, "byte")+",\n") + } + if this.MyUint64S != nil { + s = append(s, "MyUint64S: "+fmt.Sprintf("%#v", this.MyUint64S)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringCasttype(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringCasttype(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedCastaway(r randyCasttype, easy bool) *Castaway { + this := &Castaway{} + if r.Intn(10) != 0 { + v1 := int32(r.Int63()) + if r.Intn(2) == 0 { + v1 *= -1 + } + this.Int32Ptr = &v1 + } + this.Int32 = int32(r.Int63()) + if r.Intn(2) == 0 { + this.Int32 *= -1 + } + if r.Intn(10) != 0 { + v2 := github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + this.MyUint64Ptr = &v2 + } + this.MyUint64 = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + if r.Intn(10) != 0 { + v3 := r.Intn(100) + this.MyBytes = make(github_com_gogo_protobuf_test_casttype.Bytes, v3) + for i := 0; i < v3; i++ { + this.MyBytes[i] = byte(r.Intn(256)) + } + } + if r.Intn(10) != 0 { + v4 := r.Intn(100) + this.NormalBytes = make([]byte, v4) + for i := 0; i < v4; i++ { + this.NormalBytes[i] = byte(r.Intn(256)) + } + } + if r.Intn(10) != 0 { + v5 := r.Intn(100) + this.MyUint64S = make([]github_com_gogo_protobuf_test_casttype.MyUint64Type, v5) + for i := 0; i < v5; i++ { + this.MyUint64S[i] = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedCasttype(r, 8) + } + return this +} + +type randyCasttype interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneCasttype(r randyCasttype) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringCasttype(r randyCasttype) string { + v6 := r.Intn(100) + tmps := make([]rune, v6) + for i := 0; i < v6; i++ { + tmps[i] = randUTF8RuneCasttype(r) + } + return string(tmps) +} +func randUnrecognizedCasttype(r randyCasttype, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldCasttype(data, r, fieldNumber, wire) + } + return data +} +func randFieldCasttype(data []byte, r randyCasttype, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateCasttype(data, uint64(key)) + v7 := r.Int63() + if r.Intn(2) == 0 { + v7 *= -1 + } + data = encodeVarintPopulateCasttype(data, uint64(v7)) + case 1: + data = encodeVarintPopulateCasttype(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateCasttype(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateCasttype(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateCasttype(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateCasttype(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Castaway) Size() (n int) { + var l int + _ = l + if m.Int32Ptr != nil { + n += 1 + sovCasttype(uint64(*m.Int32Ptr)) + } + n += 1 + sovCasttype(uint64(m.Int32)) + if m.MyUint64Ptr != nil { + n += 1 + sovCasttype(uint64(*m.MyUint64Ptr)) + } + n += 1 + sovCasttype(uint64(m.MyUint64)) + if m.MyBytes != nil { + l = len(m.MyBytes) + n += 1 + l + sovCasttype(uint64(l)) + } + if m.NormalBytes != nil { + l = len(m.NormalBytes) + n += 1 + l + sovCasttype(uint64(l)) + } + if len(m.MyUint64S) > 0 { + for _, e := range m.MyUint64S { + n += 1 + sovCasttype(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovCasttype(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozCasttype(x uint64) (n int) { + return sovCasttype(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Castaway) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Castaway{`, + `Int32Ptr:` + valueToStringCasttype(this.Int32Ptr) + `,`, + `Int32:` + fmt.Sprintf("%v", this.Int32) + `,`, + `MyUint64Ptr:` + valueToStringCasttype(this.MyUint64Ptr) + `,`, + `MyUint64:` + fmt.Sprintf("%v", this.MyUint64) + `,`, + `MyBytes:` + valueToStringCasttype(this.MyBytes) + `,`, + `NormalBytes:` + valueToStringCasttype(this.NormalBytes) + `,`, + `MyUint64S:` + fmt.Sprintf("%v", this.MyUint64S) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringCasttype(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Castaway) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Castaway: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Castaway: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32Ptr", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Int32Ptr = &v + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32", wireType) + } + m.Int32 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Int32 |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyUint64Ptr", wireType) + } + var v github_com_gogo_protobuf_test_casttype.MyUint64Type + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (github_com_gogo_protobuf_test_casttype.MyUint64Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MyUint64Ptr = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyUint64", wireType) + } + m.MyUint64 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.MyUint64 |= (github_com_gogo_protobuf_test_casttype.MyUint64Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MyBytes", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCasttypeUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MyBytes = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NormalBytes", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthCasttypeUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NormalBytes = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyUint64S", wireType) + } + var v github_com_gogo_protobuf_test_casttype.MyUint64Type + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (github_com_gogo_protobuf_test_casttype.MyUint64Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MyUint64S = append(m.MyUint64S, v) + default: + iNdEx = preIndex + skippy, err := skipCasttypeUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthCasttypeUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipCasttypeUnsafe(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthCasttypeUnsafe + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowCasttypeUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipCasttypeUnsafe(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthCasttypeUnsafe = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowCasttypeUnsafe = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeunmarshaler/casttype.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeunmarshaler/casttype.proto new file mode 100644 index 0000000000000000000000000000000000000000..0a8b75d577d489907c3504fbc84e5dff970bbc50 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeunmarshaler/casttype.proto @@ -0,0 +1,66 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package casttype; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = true; + +message Castaway { + optional int64 Int32Ptr = 1 [(gogoproto.casttype) = "int32"]; + optional int64 Int32 = 2 [(gogoproto.nullable) = false, (gogoproto.casttype) = "int32"]; + optional uint64 MyUint64Ptr = 3 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + optional uint64 MyUint64 = 4 [(gogoproto.nullable) = false, (gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + optional bytes MyBytes = 5 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.Bytes"]; + optional bytes NormalBytes = 6; + repeated uint64 MyUint64s = 7 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeunmarshaler/casttypepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeunmarshaler/casttypepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..648145f3ec67ebc781789c59e8816e9ab2cb85da --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/combos/unsafeunmarshaler/casttypepb_test.go @@ -0,0 +1,247 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeunmarshaler/casttype.proto +// DO NOT EDIT! + +/* +Package casttype is a generated protocol buffer package. + +It is generated from these files: + combos/unsafeunmarshaler/casttype.proto + +It has these top-level messages: + Castaway +*/ +package casttype + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestCastawayProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCastawayProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Castaway, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCastaway(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCastawayProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCastaway(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Castaway{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCastawayJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Castaway{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCastawayProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCastawayProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCasttypeDescription(t *testing.T) { + CasttypeDescription() +} +func TestCastawayVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Castaway{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCastawayFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCastawayGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCastawaySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastaway(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCastawaySize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Castaway, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCastaway(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCastawayStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastaway(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/mytypes.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/mytypes.go new file mode 100644 index 0000000000000000000000000000000000000000..8bc1323422e387c311bf470a0a4e15f917959406 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype/mytypes.go @@ -0,0 +1,23 @@ +package casttype + +import ( + "encoding/json" +) + +type MyUint64Type uint64 + +type Bytes []byte + +func (this Bytes) MarshalJSON() ([]byte, error) { + return json.Marshal([]byte(this)) +} + +func (this *Bytes) UnmarshalJSON(data []byte) error { + v := new([]byte) + err := json.Unmarshal(data, v) + if err != nil { + return err + } + *this = *v + return nil +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both/bug_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both/bug_test.go new file mode 100644 index 0000000000000000000000000000000000000000..264d3982327d7276cc42c9314074f391dde60dfa --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both/bug_test.go @@ -0,0 +1,186 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 test + +import ( + "fmt" + "math" + "testing" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +) + +//http://code.google.com/p/goprotobuf/issues/detail?id=39 +func TestBugUint32VarintSize(t *testing.T) { + temp := uint32(math.MaxUint32) + n := &NinOptNative{} + n.Field5 = &temp + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != 6 { + t.Fatalf("data should be length 6, but its %#v", data) + } +} + +func TestBugZeroLengthSliceSize(t *testing.T) { + n := &NinRepPackedNative{ + Field8: []int64{}, + } + size := n.Size() + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != size { + t.Fatalf("expected %v, but got %v", len(data), size) + } +} + +//http://code.google.com/p/goprotobuf/issues/detail?id=40 +func TestBugPackedProtoSize(t *testing.T) { + n := &NinRepPackedNative{ + Field4: []int64{172960727389894724, 2360337516664475010, 860833876131988189, 9068073014890763245, 7794843386260381831, 4023536436053141786, 8992311247496919020, 4330096163611305776, 4490411416244976467, 7873947349172707443, 2754969595834279669, 1360667855926938684, 4771480785172657389, 4875578924966668055, 8070579869808877481, 9128179594766551001, 4630419407064527516, 863844540220372892, 8208727650143073487, 7086117356301045838, 7779695211931506151, 5493835345187563535, 9119767633370806007, 9054342025895349248, 1887303228838508438, 7624573031734528281, 1874668389749611225, 3517684643468970593, 6677697606628877758, 7293473953189936168, 444475066704085538, 8594971141363049302, 1146643249094989673, 733393306232853371, 7721178528893916886, 7784452000911004429, 6436373110242711440, 6897422461738321237, 8772249155667732778, 6211871464311393541, 3061903718310406883, 7845488913176136641, 8342255034663902574, 3443058984649725748, 8410801047334832902, 7496541071517841153, 4305416923521577765, 7814967600020476457, 8671843803465481186, 3490266370361096855, 1447425664719091336, 653218597262334239, 8306243902880091940, 7851896059762409081, 5936760560798954978, 5755724498441478025, 7022701569985035966, 3707709584811468220, 529069456924666920, 7986469043681522462, 3092513330689518836, 5103541550470476202, 3577384161242626406, 3733428084624703294, 8388690542440473117, 3262468785346149388, 8788358556558007570, 5476276940198542020, 7277903243119461239, 5065861426928605020, 7533460976202697734, 1749213838654236956, 557497603941617931, 5496307611456481108, 6444547750062831720, 6992758776744205596, 7356719693428537399, 2896328872476734507, 381447079530132038, 598300737753233118, 3687980626612697715, 7240924191084283349, 8172414415307971170, 4847024388701257185, 2081764168600256551, 3394217778539123488, 6244660626429310923, 8301712215675381614, 5360615125359461174, 8410140945829785773, 3152963269026381373, 6197275282781459633, 4419829061407546410, 6262035523070047537, 2837207483933463885, 2158105736666826128, 8150764172235490711}, + Field7: []int32{249451845, 1409974015, 393609128, 435232428, 1817529040, 91769006, 861170933, 1556185603, 1568580279, 1236375273, 512276621, 693633711, 967580535, 1950715977, 853431462, 1362390253, 159591204, 111900629, 322985263, 279671129, 1592548430, 465651370, 733849989, 1172059400, 1574824441, 263541092, 1271612397, 1520584358, 467078791, 117698716, 1098255064, 2054264846, 1766452305, 1267576395, 1557505617, 1187833560, 956187431, 1970977586, 1160235159, 1610259028, 489585797, 459139078, 566263183, 954319278, 1545018565, 1753946743, 948214318, 422878159, 883926576, 1424009347, 824732372, 1290433180, 80297942, 417294230, 1402647904, 2078392782, 220505045, 787368129, 463781454, 293083578, 808156928, 293976361}, + Field9: []uint32{0xaa4976e8, 0x3da8cc4c, 0x8c470d83, 0x344d964e, 0x5b90925, 0xa4c4d34e, 0x666eff19, 0xc238e552, 0x9be53bb6, 0x56364245, 0x33ee079d, 0x96bf0ede, 0x7941b74f, 0xdb07cb47, 0x6d76d827, 0x9b211d5d, 0x2798adb6, 0xe48b0c3b, 0x87061b21, 0x48f4e4d2, 0x3e5d5c12, 0x5ee91288, 0x336d4f35, 0xe1d44941, 0xc065548d, 0x2953d73f, 0x873af451, 0xfc769db, 0x9f1bf8da, 0x9baafdfc, 0xf1d3d770, 0x5bb5d2b4, 0xc2c67c48, 0x6845c4c1, 0xa48f32b0, 0xbb04bb70, 0xa5b1ca36, 0x8d98356a, 0x2171f654, 0x5ae279b0, 0x6c4a3d6b, 0x4fff5468, 0xcf9bf851, 0x68513614, 0xdbecd9b0, 0x9553ed3c, 0xa494a736, 0x42205438, 0xbf8e5caa, 0xd3283c6, 0x76d20788, 0x9179826f, 0x96b24f85, 0xbc2eacf4, 0xe4afae0b, 0x4bca85cb, 0x35e63b5b, 0xd7ccee0c, 0x2b506bb9, 0xe78e9f44, 0x9ad232f1, 0x99a37335, 0xa5d6ffc8}, + Field11: []uint64{0x53c01ebc, 0x4fb85ba6, 0x8805eea1, 0xb20ec896, 0x93b63410, 0xec7c9492, 0x50765a28, 0x19592106, 0x2ecc59b3, 0x39cd474f, 0xe4c9e47, 0x444f48c5, 0xe7731d32, 0xf3f43975, 0x603caedd, 0xbb05a1af, 0xa808e34e, 0x88580b07, 0x4c96bbd1, 0x730b4ab9, 0xed126e2b, 0x6db48205, 0x154ba1b9, 0xc26bfb6a, 0x389aa052, 0x869d966c, 0x7c86b366, 0xcc8edbcd, 0xfa8d6dad, 0xcf5857d9, 0x2d9cda0f, 0x1218a0b8, 0x41bf997, 0xf0ca65ac, 0xa610d4b9, 0x8d362e28, 0xb7212d87, 0x8e0fe109, 0xbee041d9, 0x759be2f6, 0x35fef4f3, 0xaeacdb71, 0x10888852, 0xf4e28117, 0xe2a14812, 0x73b748dc, 0xd1c3c6b2, 0xfef41bf0, 0xc9b43b62, 0x810e4faa, 0xcaa41c06, 0x1893fe0d, 0xedc7c850, 0xd12b9eaa, 0x467ee1a9, 0xbe84756b, 0xda7b1680, 0xdc069ffe, 0xf1e7e9f9, 0xb3d95370, 0xa92b77df, 0x5693ac41, 0xd04b7287, 0x27aebf15, 0x837b316e, 0x4dbe2263, 0xbab70c67, 0x547dab21, 0x3c346c1f, 0xb8ef0e4e, 0xfe2d03ce, 0xe1d75955, 0xfec1306, 0xba35c23e, 0xb784ed04, 0x2a4e33aa, 0x7e19d09a, 0x3827c1fe, 0xf3a51561, 0xef765e2b, 0xb044256c, 0x62b322be, 0xf34d56be, 0xeb71b369, 0xffe1294f, 0x237fe8d0, 0x77a1473b, 0x239e1196, 0xdd19bf3d, 0x82c91fe1, 0x95361c57, 0xffea3f1b, 0x1a094c84}, + Field12: []int64{8308420747267165049, 3664160795077875961, 7868970059161834817, 7237335984251173739, 5254748003907196506, 3362259627111837480, 430460752854552122, 5119635556501066533, 1277716037866233522, 9185775384759813768, 833932430882717888, 7986528304451297640, 6792233378368656337, 2074207091120609721, 1788723326198279432, 7756514594746453657, 2283775964901597324, 3061497730110517191, 7733947890656120277, 626967303632386244, 7822928600388582821, 3489658753000061230, 168869995163005961, 248814782163480763, 477885608911386247, 4198422415674133867, 3379354662797976109, 9925112544736939, 1486335136459138480, 4561560414032850671, 1010864164014091267, 186722821683803084, 5106357936724819318, 1298160820191228988, 4675403242419953145, 7130634540106489752, 7101280006672440929, 7176058292431955718, 9109875054097770321, 6810974877085322872, 4736707874303993641, 8993135362721382187, 6857881554990254283, 3704748883307461680, 1099360832887634994, 5207691918707192633, 5984721695043995243}, + } + size := proto.Size(n) + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != size { + t.Fatalf("expected %v, but got %v diff is %v", len(data), size, len(data)-size) + } +} + +func testSize(m interface { + proto.Message + Size() int +}, desc string, expected int) ([]byte, error) { + data, err := proto.Marshal(m) + if err != nil { + return nil, err + } + protoSize := proto.Size(m) + mSize := m.Size() + lenData := len(data) + if protoSize != mSize || protoSize != lenData || mSize != lenData { + return nil, fmt.Errorf("%s proto.Size(m){%d} != m.Size(){%d} != len(data){%d}", desc, protoSize, mSize, lenData) + } + if got := protoSize; got != expected { + return nil, fmt.Errorf("%s proto.Size(m) got %d expected %d", desc, got, expected) + } + if got := mSize; got != expected { + return nil, fmt.Errorf("%s m.Size() got %d expected %d", desc, got, expected) + } + if got := lenData; got != expected { + return nil, fmt.Errorf("%s len(data) got %d expected %d", desc, got, expected) + } + return data, nil +} + +func TestInt32Int64Compatibility(t *testing.T) { + + //test nullable int32 and int64 + + data1, err := testSize(&NinOptNative{ + Field3: proto.Int32(-1), + }, "nullable", 11) + if err != nil { + t.Error(err) + } + //change marshaled data1 to unmarshal into 4th field which is an int64 + data1[0] = uint8(uint32(4 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + u1 := &NinOptNative{} + if err := proto.Unmarshal(data1, u1); err != nil { + t.Error(err) + } + if !u1.Equal(&NinOptNative{ + Field4: proto.Int64(-1), + }) { + t.Error("nullable unmarshaled int32 is not the same int64") + } + + //test non-nullable int32 and int64 + + data2, err := testSize(&NidOptNative{ + Field3: -1, + }, "non nullable", 67) + if err != nil { + t.Error(err) + } + //change marshaled data2 to unmarshal into 4th field which is an int64 + field3 := uint8(uint32(3 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + field4 := uint8(uint32(4 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + for i, c := range data2 { + if c == field4 { + data2[i] = field3 + } else if c == field3 { + data2[i] = field4 + } + } + u2 := &NidOptNative{} + if err := proto.Unmarshal(data2, u2); err != nil { + t.Error(err) + } + if !u2.Equal(&NidOptNative{ + Field4: -1, + }) { + t.Error("non nullable unmarshaled int32 is not the same int64") + } + + //test packed repeated int32 and int64 + + m4 := &NinRepPackedNative{ + Field3: []int32{-1}, + } + data4, err := testSize(m4, "packed", 12) + if err != nil { + t.Error(err) + } + u4 := &NinRepPackedNative{} + if err := proto.Unmarshal(data4, u4); err != nil { + t.Error(err) + } + if err := u4.VerboseEqual(m4); err != nil { + t.Fatalf("%#v", u4) + } + + //test repeated int32 and int64 + + if _, err := testSize(&NinRepNative{ + Field3: []int32{-1}, + }, "repeated", 11); err != nil { + t.Error(err) + } + + t.Logf("tested all") +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both/thetest.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both/thetest.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..a5d7d39d7aa7155810616b4c596284885bb0c663 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both/thetest.pb.go @@ -0,0 +1,37069 @@ +// Code generated by protoc-gen-gogo. +// source: combos/both/thetest.proto +// DO NOT EDIT! + +/* + Package test is a generated protocol buffer package. + + It is generated from these files: + combos/both/thetest.proto + + It has these top-level messages: + NidOptNative + NinOptNative + NidRepNative + NinRepNative + NidRepPackedNative + NinRepPackedNative + NidOptStruct + NinOptStruct + NidRepStruct + NinRepStruct + NidEmbeddedStruct + NinEmbeddedStruct + NidNestedStruct + NinNestedStruct + NidOptCustom + CustomDash + NinOptCustom + NidRepCustom + NinRepCustom + NinOptNativeUnion + NinOptStructUnion + NinEmbeddedStructUnion + NinNestedStructUnion + Tree + OrBranch + AndBranch + Leaf + DeepTree + ADeepBranch + AndDeepBranch + DeepLeaf + Nil + NidOptEnum + NinOptEnum + NidRepEnum + NinRepEnum + NinOptEnumDefault + AnotherNinOptEnum + AnotherNinOptEnumDefault + Timer + MyExtendable + OtherExtenable + NestedDefinition + NestedScope + NinOptNativeDefault + CustomContainer + CustomNameNidOptNative + CustomNameNinOptNative + CustomNameNinRepNative + CustomNameNinStruct + CustomNameCustomType + CustomNameNinEmbeddedStructUnion + CustomNameEnum + NoExtensionsMap + Unrecognized + UnrecognizedWithInner + UnrecognizedWithEmbed +*/ +package test + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_custom "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom" +import github_com_gogo_protobuf_test_custom_dash_type "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom-dash-type" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type TheTestEnum int32 + +const ( + A TheTestEnum = 0 + B TheTestEnum = 1 + C TheTestEnum = 2 +) + +var TheTestEnum_name = map[int32]string{ + 0: "A", + 1: "B", + 2: "C", +} +var TheTestEnum_value = map[string]int32{ + "A": 0, + "B": 1, + "C": 2, +} + +func (x TheTestEnum) Enum() *TheTestEnum { + p := new(TheTestEnum) + *p = x + return p +} +func (x TheTestEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(TheTestEnum_name, int32(x)) +} +func (x *TheTestEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(TheTestEnum_value, data, "TheTestEnum") + if err != nil { + return err + } + *x = TheTestEnum(value) + return nil +} + +type AnotherTestEnum int32 + +const ( + D AnotherTestEnum = 10 + E AnotherTestEnum = 11 +) + +var AnotherTestEnum_name = map[int32]string{ + 10: "D", + 11: "E", +} +var AnotherTestEnum_value = map[string]int32{ + "D": 10, + "E": 11, +} + +func (x AnotherTestEnum) Enum() *AnotherTestEnum { + p := new(AnotherTestEnum) + *p = x + return p +} +func (x AnotherTestEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(AnotherTestEnum_name, int32(x)) +} +func (x *AnotherTestEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(AnotherTestEnum_value, data, "AnotherTestEnum") + if err != nil { + return err + } + *x = AnotherTestEnum(value) + return nil +} + +type NestedDefinition_NestedEnum int32 + +const ( + TYPE_NESTED NestedDefinition_NestedEnum = 1 +) + +var NestedDefinition_NestedEnum_name = map[int32]string{ + 1: "TYPE_NESTED", +} +var NestedDefinition_NestedEnum_value = map[string]int32{ + "TYPE_NESTED": 1, +} + +func (x NestedDefinition_NestedEnum) Enum() *NestedDefinition_NestedEnum { + p := new(NestedDefinition_NestedEnum) + *p = x + return p +} +func (x NestedDefinition_NestedEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(NestedDefinition_NestedEnum_name, int32(x)) +} +func (x *NestedDefinition_NestedEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(NestedDefinition_NestedEnum_value, data, "NestedDefinition_NestedEnum") + if err != nil { + return err + } + *x = NestedDefinition_NestedEnum(value) + return nil +} + +type NidOptNative struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + Field3 int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3"` + Field4 int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4"` + Field5 uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5"` + Field6 uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8"` + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9"` + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10"` + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11"` + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12"` + Field13 bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + Field14 string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptNative) Reset() { *m = NidOptNative{} } +func (*NidOptNative) ProtoMessage() {} + +type NinOptNative struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"` + Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"` + Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"` + Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"` + Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNative) Reset() { *m = NinOptNative{} } +func (*NinOptNative) ProtoMessage() {} + +type NidRepNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepNative) Reset() { *m = NidRepNative{} } +func (*NidRepNative) ProtoMessage() {} + +type NinRepNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepNative) Reset() { *m = NinRepNative{} } +func (*NinRepNative) ProtoMessage() {} + +type NidRepPackedNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepPackedNative) Reset() { *m = NidRepPackedNative{} } +func (*NidRepPackedNative) ProtoMessage() {} + +type NinRepPackedNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepPackedNative) Reset() { *m = NinRepPackedNative{} } +func (*NinRepPackedNative) ProtoMessage() {} + +type NidOptStruct struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + Field3 NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3"` + Field4 NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4"` + Field6 uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + Field8 NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8"` + Field13 bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + Field14 string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptStruct) Reset() { *m = NidOptStruct{} } +func (*NidOptStruct) ProtoMessage() {} + +type NinOptStruct struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field8 *NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptStruct) Reset() { *m = NinOptStruct{} } +func (*NinOptStruct) ProtoMessage() {} + +type NidRepStruct struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []NidOptNative `protobuf:"bytes,3,rep,name=Field3" json:"Field3"` + Field4 []NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []NidOptNative `protobuf:"bytes,8,rep,name=Field8" json:"Field8"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepStruct) Reset() { *m = NidRepStruct{} } +func (*NidRepStruct) ProtoMessage() {} + +type NinRepStruct struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []*NidOptNative `protobuf:"bytes,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []*NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []*NidOptNative `protobuf:"bytes,8,rep,name=Field8" json:"Field8,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepStruct) Reset() { *m = NinRepStruct{} } +func (*NinRepStruct) ProtoMessage() {} + +type NidEmbeddedStruct struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 NidOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200"` + Field210 bool `protobuf:"varint,210,opt,name=Field210" json:"Field210"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidEmbeddedStruct) Reset() { *m = NidEmbeddedStruct{} } +func (*NidEmbeddedStruct) ProtoMessage() {} + +type NinEmbeddedStruct struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 *NidOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + Field210 *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinEmbeddedStruct) Reset() { *m = NinEmbeddedStruct{} } +func (*NinEmbeddedStruct) ProtoMessage() {} + +type NidNestedStruct struct { + Field1 NidOptStruct `protobuf:"bytes,1,opt,name=Field1" json:"Field1"` + Field2 []NidRepStruct `protobuf:"bytes,2,rep,name=Field2" json:"Field2"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidNestedStruct) Reset() { *m = NidNestedStruct{} } +func (*NidNestedStruct) ProtoMessage() {} + +type NinNestedStruct struct { + Field1 *NinOptStruct `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 []*NinRepStruct `protobuf:"bytes,2,rep,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinNestedStruct) Reset() { *m = NinNestedStruct{} } +func (*NinNestedStruct) ProtoMessage() {} + +type NidOptCustom struct { + Id Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id"` + Value github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptCustom) Reset() { *m = NidOptCustom{} } +func (*NidOptCustom) ProtoMessage() {} + +type CustomDash struct { + Value *github_com_gogo_protobuf_test_custom_dash_type.Bytes `protobuf:"bytes,1,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom-dash-type.Bytes" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomDash) Reset() { *m = CustomDash{} } +func (*CustomDash) ProtoMessage() {} + +type NinOptCustom struct { + Id *Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id,omitempty"` + Value *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptCustom) Reset() { *m = NinOptCustom{} } +func (*NinOptCustom) ProtoMessage() {} + +type NidRepCustom struct { + Id []Uuid `protobuf:"bytes,1,rep,name=Id,customtype=Uuid" json:"Id"` + Value []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepCustom) Reset() { *m = NidRepCustom{} } +func (*NidRepCustom) ProtoMessage() {} + +type NinRepCustom struct { + Id []Uuid `protobuf:"bytes,1,rep,name=Id,customtype=Uuid" json:"Id,omitempty"` + Value []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepCustom) Reset() { *m = NinRepCustom{} } +func (*NinRepCustom) ProtoMessage() {} + +type NinOptNativeUnion struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNativeUnion) Reset() { *m = NinOptNativeUnion{} } +func (*NinOptNativeUnion) ProtoMessage() {} + +type NinOptStructUnion struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptStructUnion) Reset() { *m = NinOptStructUnion{} } +func (*NinOptStructUnion) ProtoMessage() {} + +type NinEmbeddedStructUnion struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 *NinOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + Field210 *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinEmbeddedStructUnion) Reset() { *m = NinEmbeddedStructUnion{} } +func (*NinEmbeddedStructUnion) ProtoMessage() {} + +type NinNestedStructUnion struct { + Field1 *NinOptNativeUnion `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *NinOptStructUnion `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NinEmbeddedStructUnion `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinNestedStructUnion) Reset() { *m = NinNestedStructUnion{} } +func (*NinNestedStructUnion) ProtoMessage() {} + +type Tree struct { + Or *OrBranch `protobuf:"bytes,1,opt,name=Or" json:"Or,omitempty"` + And *AndBranch `protobuf:"bytes,2,opt,name=And" json:"And,omitempty"` + Leaf *Leaf `protobuf:"bytes,3,opt,name=Leaf" json:"Leaf,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Tree) Reset() { *m = Tree{} } +func (*Tree) ProtoMessage() {} + +type OrBranch struct { + Left Tree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right Tree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OrBranch) Reset() { *m = OrBranch{} } +func (*OrBranch) ProtoMessage() {} + +type AndBranch struct { + Left Tree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right Tree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AndBranch) Reset() { *m = AndBranch{} } +func (*AndBranch) ProtoMessage() {} + +type Leaf struct { + Value int64 `protobuf:"varint,1,opt,name=Value" json:"Value"` + StrValue string `protobuf:"bytes,2,opt,name=StrValue" json:"StrValue"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Leaf) Reset() { *m = Leaf{} } +func (*Leaf) ProtoMessage() {} + +type DeepTree struct { + Down *ADeepBranch `protobuf:"bytes,1,opt,name=Down" json:"Down,omitempty"` + And *AndDeepBranch `protobuf:"bytes,2,opt,name=And" json:"And,omitempty"` + Leaf *DeepLeaf `protobuf:"bytes,3,opt,name=Leaf" json:"Leaf,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeepTree) Reset() { *m = DeepTree{} } +func (*DeepTree) ProtoMessage() {} + +type ADeepBranch struct { + Down DeepTree `protobuf:"bytes,2,opt,name=Down" json:"Down"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ADeepBranch) Reset() { *m = ADeepBranch{} } +func (*ADeepBranch) ProtoMessage() {} + +type AndDeepBranch struct { + Left DeepTree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right DeepTree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AndDeepBranch) Reset() { *m = AndDeepBranch{} } +func (*AndDeepBranch) ProtoMessage() {} + +type DeepLeaf struct { + Tree Tree `protobuf:"bytes,1,opt,name=Tree" json:"Tree"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeepLeaf) Reset() { *m = DeepLeaf{} } +func (*DeepLeaf) ProtoMessage() {} + +type Nil struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *Nil) Reset() { *m = Nil{} } +func (*Nil) ProtoMessage() {} + +type NidOptEnum struct { + Field1 TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptEnum) Reset() { *m = NidOptEnum{} } +func (*NidOptEnum) ProtoMessage() {} + +type NinOptEnum struct { + Field1 *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptEnum) Reset() { *m = NinOptEnum{} } +func (*NinOptEnum) ProtoMessage() {} + +type NidRepEnum struct { + Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepEnum) Reset() { *m = NidRepEnum{} } +func (*NidRepEnum) ProtoMessage() {} + +type NinRepEnum struct { + Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepEnum) Reset() { *m = NinRepEnum{} } +func (*NinRepEnum) ProtoMessage() {} + +type NinOptEnumDefault struct { + Field1 *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum,def=2" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptEnumDefault) Reset() { *m = NinOptEnumDefault{} } +func (*NinOptEnumDefault) ProtoMessage() {} + +const Default_NinOptEnumDefault_Field1 TheTestEnum = C + +func (m *NinOptEnumDefault) GetField1() TheTestEnum { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_NinOptEnumDefault_Field1 +} + +type AnotherNinOptEnum struct { + Field1 *AnotherTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.AnotherTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AnotherNinOptEnum) Reset() { *m = AnotherNinOptEnum{} } +func (*AnotherNinOptEnum) ProtoMessage() {} + +type AnotherNinOptEnumDefault struct { + Field1 *AnotherTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.AnotherTestEnum,def=11" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AnotherNinOptEnumDefault) Reset() { *m = AnotherNinOptEnumDefault{} } +func (*AnotherNinOptEnumDefault) ProtoMessage() {} + +const Default_AnotherNinOptEnumDefault_Field1 AnotherTestEnum = E + +func (m *AnotherNinOptEnumDefault) GetField1() AnotherTestEnum { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_AnotherNinOptEnumDefault_Field1 +} + +type Timer struct { + Time1 int64 `protobuf:"fixed64,1,opt,name=Time1" json:"Time1"` + Time2 int64 `protobuf:"fixed64,2,opt,name=Time2" json:"Time2"` + Data []byte `protobuf:"bytes,3,opt,name=Data" json:"Data"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Timer) Reset() { *m = Timer{} } +func (*Timer) ProtoMessage() {} + +type MyExtendable struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MyExtendable) Reset() { *m = MyExtendable{} } +func (*MyExtendable) ProtoMessage() {} + +var extRange_MyExtendable = []proto.ExtensionRange{ + {100, 199}, +} + +func (*MyExtendable) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MyExtendable +} +func (m *MyExtendable) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type OtherExtenable struct { + Field2 *int64 `protobuf:"varint,2,opt,name=Field2" json:"Field2,omitempty"` + Field13 *int64 `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + M *MyExtendable `protobuf:"bytes,1,opt,name=M" json:"M,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OtherExtenable) Reset() { *m = OtherExtenable{} } +func (*OtherExtenable) ProtoMessage() {} + +var extRange_OtherExtenable = []proto.ExtensionRange{ + {14, 16}, + {10, 12}, +} + +func (*OtherExtenable) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_OtherExtenable +} +func (m *OtherExtenable) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type NestedDefinition struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + EnumField *NestedDefinition_NestedEnum `protobuf:"varint,2,opt,name=EnumField,enum=test.NestedDefinition_NestedEnum" json:"EnumField,omitempty"` + NNM *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,3,opt,name=NNM" json:"NNM,omitempty"` + NM *NestedDefinition_NestedMessage `protobuf:"bytes,4,opt,name=NM" json:"NM,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition) Reset() { *m = NestedDefinition{} } +func (*NestedDefinition) ProtoMessage() {} + +type NestedDefinition_NestedMessage struct { + NestedField1 *uint64 `protobuf:"fixed64,1,opt,name=NestedField1" json:"NestedField1,omitempty"` + NNM *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,2,opt,name=NNM" json:"NNM,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition_NestedMessage) Reset() { *m = NestedDefinition_NestedMessage{} } +func (*NestedDefinition_NestedMessage) ProtoMessage() {} + +type NestedDefinition_NestedMessage_NestedNestedMsg struct { + NestedNestedField1 *string `protobuf:"bytes,10,opt,name=NestedNestedField1" json:"NestedNestedField1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Reset() { + *m = NestedDefinition_NestedMessage_NestedNestedMsg{} +} +func (*NestedDefinition_NestedMessage_NestedNestedMsg) ProtoMessage() {} + +type NestedScope struct { + A *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,1,opt,name=A" json:"A,omitempty"` + B *NestedDefinition_NestedEnum `protobuf:"varint,2,opt,name=B,enum=test.NestedDefinition_NestedEnum" json:"B,omitempty"` + C *NestedDefinition_NestedMessage `protobuf:"bytes,3,opt,name=C" json:"C,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedScope) Reset() { *m = NestedScope{} } +func (*NestedScope) ProtoMessage() {} + +type NinOptNativeDefault struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1,def=1234.1234" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2,def=1234.1234" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3,def=1234" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4,def=1234" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5,def=1234" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6,def=1234" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7,def=1234" json:"Field7,omitempty"` + Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8,def=1234" json:"Field8,omitempty"` + Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9,def=1234" json:"Field9,omitempty"` + Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10,def=1234" json:"Field10,omitempty"` + Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11,def=1234" json:"Field11,omitempty"` + Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12,def=1234" json:"Field12,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13,def=1" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14,def=1234" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNativeDefault) Reset() { *m = NinOptNativeDefault{} } +func (*NinOptNativeDefault) ProtoMessage() {} + +const Default_NinOptNativeDefault_Field1 float64 = 1234.1234 +const Default_NinOptNativeDefault_Field2 float32 = 1234.1234 +const Default_NinOptNativeDefault_Field3 int32 = 1234 +const Default_NinOptNativeDefault_Field4 int64 = 1234 +const Default_NinOptNativeDefault_Field5 uint32 = 1234 +const Default_NinOptNativeDefault_Field6 uint64 = 1234 +const Default_NinOptNativeDefault_Field7 int32 = 1234 +const Default_NinOptNativeDefault_Field8 int64 = 1234 +const Default_NinOptNativeDefault_Field9 uint32 = 1234 +const Default_NinOptNativeDefault_Field10 int32 = 1234 +const Default_NinOptNativeDefault_Field11 uint64 = 1234 +const Default_NinOptNativeDefault_Field12 int64 = 1234 +const Default_NinOptNativeDefault_Field13 bool = true +const Default_NinOptNativeDefault_Field14 string = "1234" + +func (m *NinOptNativeDefault) GetField1() float64 { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_NinOptNativeDefault_Field1 +} + +func (m *NinOptNativeDefault) GetField2() float32 { + if m != nil && m.Field2 != nil { + return *m.Field2 + } + return Default_NinOptNativeDefault_Field2 +} + +func (m *NinOptNativeDefault) GetField3() int32 { + if m != nil && m.Field3 != nil { + return *m.Field3 + } + return Default_NinOptNativeDefault_Field3 +} + +func (m *NinOptNativeDefault) GetField4() int64 { + if m != nil && m.Field4 != nil { + return *m.Field4 + } + return Default_NinOptNativeDefault_Field4 +} + +func (m *NinOptNativeDefault) GetField5() uint32 { + if m != nil && m.Field5 != nil { + return *m.Field5 + } + return Default_NinOptNativeDefault_Field5 +} + +func (m *NinOptNativeDefault) GetField6() uint64 { + if m != nil && m.Field6 != nil { + return *m.Field6 + } + return Default_NinOptNativeDefault_Field6 +} + +func (m *NinOptNativeDefault) GetField7() int32 { + if m != nil && m.Field7 != nil { + return *m.Field7 + } + return Default_NinOptNativeDefault_Field7 +} + +func (m *NinOptNativeDefault) GetField8() int64 { + if m != nil && m.Field8 != nil { + return *m.Field8 + } + return Default_NinOptNativeDefault_Field8 +} + +func (m *NinOptNativeDefault) GetField9() uint32 { + if m != nil && m.Field9 != nil { + return *m.Field9 + } + return Default_NinOptNativeDefault_Field9 +} + +func (m *NinOptNativeDefault) GetField10() int32 { + if m != nil && m.Field10 != nil { + return *m.Field10 + } + return Default_NinOptNativeDefault_Field10 +} + +func (m *NinOptNativeDefault) GetField11() uint64 { + if m != nil && m.Field11 != nil { + return *m.Field11 + } + return Default_NinOptNativeDefault_Field11 +} + +func (m *NinOptNativeDefault) GetField12() int64 { + if m != nil && m.Field12 != nil { + return *m.Field12 + } + return Default_NinOptNativeDefault_Field12 +} + +func (m *NinOptNativeDefault) GetField13() bool { + if m != nil && m.Field13 != nil { + return *m.Field13 + } + return Default_NinOptNativeDefault_Field13 +} + +func (m *NinOptNativeDefault) GetField14() string { + if m != nil && m.Field14 != nil { + return *m.Field14 + } + return Default_NinOptNativeDefault_Field14 +} + +func (m *NinOptNativeDefault) GetField15() []byte { + if m != nil { + return m.Field15 + } + return nil +} + +type CustomContainer struct { + CustomStruct NidOptCustom `protobuf:"bytes,1,opt,name=CustomStruct" json:"CustomStruct"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomContainer) Reset() { *m = CustomContainer{} } +func (*CustomContainer) ProtoMessage() {} + +type CustomNameNidOptNative struct { + FieldA float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + FieldB float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + FieldC int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3"` + FieldD int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4"` + FieldE uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5"` + FieldF uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + FieldG int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + FieldH int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8"` + FieldI uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9"` + FieldJ int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10"` + FieldK uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11"` + FieldL int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12"` + FieldM bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + FieldN string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + FieldO []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNidOptNative) Reset() { *m = CustomNameNidOptNative{} } +func (*CustomNameNidOptNative) ProtoMessage() {} + +type CustomNameNinOptNative struct { + FieldA *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + FieldB *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + FieldC *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + FieldD *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + FieldE *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + FieldF *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + FieldG *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + FieldH *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"` + FieldI *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"` + FieldJ *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"` + FieldK *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"` + FielL *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"` + FieldM *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + FieldN *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + FieldO []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinOptNative) Reset() { *m = CustomNameNinOptNative{} } +func (*CustomNameNinOptNative) ProtoMessage() {} + +type CustomNameNinRepNative struct { + FieldA []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + FieldB []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + FieldC []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + FieldD []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + FieldE []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + FieldF []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + FieldG []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + FieldH []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + FieldI []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + FieldJ []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + FieldK []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + FieldL []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + FieldM []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + FieldN []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + FieldO [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinRepNative) Reset() { *m = CustomNameNinRepNative{} } +func (*CustomNameNinRepNative) ProtoMessage() {} + +type CustomNameNinStruct struct { + FieldA *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + FieldB *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + FieldC *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + FieldD []*NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4,omitempty"` + FieldE *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + FieldF *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + FieldG *NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"` + FieldH *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + FieldI *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + FieldJ []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinStruct) Reset() { *m = CustomNameNinStruct{} } +func (*CustomNameNinStruct) ProtoMessage() {} + +type CustomNameCustomType struct { + FieldA *Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id,omitempty"` + FieldB *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + FieldC []Uuid `protobuf:"bytes,3,rep,name=Ids,customtype=Uuid" json:"Ids,omitempty"` + FieldD []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,4,rep,name=Values,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Values,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameCustomType) Reset() { *m = CustomNameCustomType{} } +func (*CustomNameCustomType) ProtoMessage() {} + +type CustomNameNinEmbeddedStructUnion struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + FieldA *NinOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + FieldB *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinEmbeddedStructUnion) Reset() { *m = CustomNameNinEmbeddedStructUnion{} } +func (*CustomNameNinEmbeddedStructUnion) ProtoMessage() {} + +type CustomNameEnum struct { + FieldA *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + FieldB []TheTestEnum `protobuf:"varint,2,rep,name=Field2,enum=test.TheTestEnum" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameEnum) Reset() { *m = CustomNameEnum{} } +func (*CustomNameEnum) ProtoMessage() {} + +type NoExtensionsMap struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + XXX_extensions []byte `protobuf:"bytes,0,opt" json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NoExtensionsMap) Reset() { *m = NoExtensionsMap{} } +func (*NoExtensionsMap) ProtoMessage() {} + +var extRange_NoExtensionsMap = []proto.ExtensionRange{ + {100, 199}, +} + +func (*NoExtensionsMap) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_NoExtensionsMap +} +func (m *NoExtensionsMap) GetExtensions() *[]byte { + if m.XXX_extensions == nil { + m.XXX_extensions = make([]byte, 0) + } + return &m.XXX_extensions +} + +type Unrecognized struct { + Field1 *string `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *Unrecognized) Reset() { *m = Unrecognized{} } +func (*Unrecognized) ProtoMessage() {} + +type UnrecognizedWithInner struct { + Embedded []*UnrecognizedWithInner_Inner `protobuf:"bytes,1,rep,name=embedded" json:"embedded,omitempty"` + Field2 *string `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnrecognizedWithInner) Reset() { *m = UnrecognizedWithInner{} } +func (*UnrecognizedWithInner) ProtoMessage() {} + +type UnrecognizedWithInner_Inner struct { + Field1 *uint32 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *UnrecognizedWithInner_Inner) Reset() { *m = UnrecognizedWithInner_Inner{} } +func (*UnrecognizedWithInner_Inner) ProtoMessage() {} + +type UnrecognizedWithEmbed struct { + UnrecognizedWithEmbed_Embedded `protobuf:"bytes,1,opt,name=embedded,embedded=embedded" json:"embedded"` + Field2 *string `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnrecognizedWithEmbed) Reset() { *m = UnrecognizedWithEmbed{} } +func (*UnrecognizedWithEmbed) ProtoMessage() {} + +type UnrecognizedWithEmbed_Embedded struct { + Field1 *uint32 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *UnrecognizedWithEmbed_Embedded) Reset() { *m = UnrecognizedWithEmbed_Embedded{} } +func (*UnrecognizedWithEmbed_Embedded) ProtoMessage() {} + +var E_FieldA = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*float64)(nil), + Field: 100, + Name: "test.FieldA", + Tag: "fixed64,100,opt,name=FieldA", +} + +var E_FieldB = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*NinOptNative)(nil), + Field: 101, + Name: "test.FieldB", + Tag: "bytes,101,opt,name=FieldB", +} + +var E_FieldC = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*NinEmbeddedStruct)(nil), + Field: 102, + Name: "test.FieldC", + Tag: "bytes,102,opt,name=FieldC", +} + +var E_FieldA1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*float64)(nil), + Field: 100, + Name: "test.FieldA1", + Tag: "fixed64,100,opt,name=FieldA1", +} + +var E_FieldB1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*NinOptNative)(nil), + Field: 101, + Name: "test.FieldB1", + Tag: "bytes,101,opt,name=FieldB1", +} + +var E_FieldC1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*NinEmbeddedStruct)(nil), + Field: 102, + Name: "test.FieldC1", + Tag: "bytes,102,opt,name=FieldC1", +} + +func init() { + proto.RegisterEnum("test.TheTestEnum", TheTestEnum_name, TheTestEnum_value) + proto.RegisterEnum("test.AnotherTestEnum", AnotherTestEnum_name, AnotherTestEnum_value) + proto.RegisterEnum("test.NestedDefinition_NestedEnum", NestedDefinition_NestedEnum_name, NestedDefinition_NestedEnum_value) + proto.RegisterExtension(E_FieldA) + proto.RegisterExtension(E_FieldB) + proto.RegisterExtension(E_FieldC) + proto.RegisterExtension(E_FieldA1) + proto.RegisterExtension(E_FieldB1) + proto.RegisterExtension(E_FieldC1) +} +func (this *NidOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepPackedNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepPackedNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidEmbeddedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinEmbeddedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidNestedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinNestedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomDash) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNativeUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinEmbeddedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinNestedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Tree) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *OrBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AndBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Leaf) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *DeepTree) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *ADeepBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AndDeepBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *DeepLeaf) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Nil) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptEnumDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AnotherNinOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AnotherNinOptEnumDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Timer) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *MyExtendable) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *OtherExtenable) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition_NestedMessage) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedScope) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNativeDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomContainer) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNidOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameCustomType) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinEmbeddedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NoExtensionsMap) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Unrecognized) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithInner) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithInner_Inner) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithEmbed) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithEmbed_Embedded) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func ThetestDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/both/thetest.proto"), + Package: func(v string) *string { return &v }("test"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NinRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NidOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }, {Name: func(v string) *string { return &v }("NidNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidRepStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStruct"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinRepStruct"), + }}, + }, {Name: func(v string) *string { return &v }("NidOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomDash"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x64, 0x61, 0x73, 0x68, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NidRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinOptStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinNestedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNativeUnion"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStructUnion"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStructUnion"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Tree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Or"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.OrBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Leaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("OrBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Leaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("StrValue"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepTree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.ADeepBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndDeepBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepLeaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("ADeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndDeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepLeaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Tree"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Nil")}, {Name: func(v string) *string { return &v }("NidOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NidRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + DefaultValue: func(v string) *string { return &v }("C"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + DefaultValue: func(v string) *string { return &v }("E"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Timer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Time1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Time2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Data"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("MyExtendable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("OtherExtenable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("M"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.MyExtendable"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(14), + End: func(v int32) *int32 { return &v }(17), + }, {Start: func(v int32) *int32 { return &v }(10), + End: func(v int32) *int32 { return &v }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("NestedDefinition"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("EnumField"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("NM"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedMessage"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedField1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedMsg"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedField1"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("NestedEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_NESTED"), + Number: func(v int32) *int32 { return &v }(1), + }}, + }}, + }, {Name: func(v string) *string { return &v }("NestedScope"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("true"), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("CustomContainer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("CustomStruct"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptCustom"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x5, 0x46, 0x69, 0x65, 0x6c, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameCustomType"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Ids"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Values"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("CustomNameEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + }, {Name: func(v string) *string { return &v }("NoExtensionsMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0}), 64025: proto.NewExtension([]byte{0xc8, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Unrecognized"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithInner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithInner.Inner"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Inner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithEmbed"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithEmbed.Embedded"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Embedded"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("TheTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }, {Name: func(v string) *string { return &v }("AnotherTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("D"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("E"), + Number: func(v int32) *int32 { return &v }(11), + }}, + Options: &google_protobuf.EnumOptions{XXX_extensions: map[int32]proto.Extension{62001: proto.NewExtension([]byte{0x88, 0xa3, 0x1e, 0x0})}}, + }}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("FieldA"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldB"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldC"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldA1"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldB1"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldC1"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (x TheTestEnum) String() string { + s, ok := TheTestEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x AnotherTestEnum) String() string { + s, ok := AnotherTestEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x NestedDefinition_NestedEnum) String() string { + s, ok := NestedDefinition_NestedEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *NidOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptNative) + if !ok { + return fmt.Errorf("that is not of type *NidOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptNativebut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if this.Field2 != that1.Field2 { + return false + } + if this.Field3 != that1.Field3 { + return false + } + if this.Field4 != that1.Field4 { + return false + } + if this.Field5 != that1.Field5 { + return false + } + if this.Field6 != that1.Field6 { + return false + } + if this.Field7 != that1.Field7 { + return false + } + if this.Field8 != that1.Field8 { + return false + } + if this.Field9 != that1.Field9 { + return false + } + if this.Field10 != that1.Field10 { + return false + } + if this.Field11 != that1.Field11 { + return false + } + if this.Field12 != that1.Field12 { + return false + } + if this.Field13 != that1.Field13 { + return false + } + if this.Field14 != that1.Field14 { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNative) + if !ok { + return fmt.Errorf("that is not of type *NinOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativebut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", *this.Field8, *that1.Field8) + } + } else if this.Field8 != nil { + return fmt.Errorf("this.Field8 == nil && that.Field8 != nil") + } else if that1.Field8 != nil { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", *this.Field9, *that1.Field9) + } + } else if this.Field9 != nil { + return fmt.Errorf("this.Field9 == nil && that.Field9 != nil") + } else if that1.Field9 != nil { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", *this.Field10, *that1.Field10) + } + } else if this.Field10 != nil { + return fmt.Errorf("this.Field10 == nil && that.Field10 != nil") + } else if that1.Field10 != nil { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", *this.Field11, *that1.Field11) + } + } else if this.Field11 != nil { + return fmt.Errorf("this.Field11 == nil && that.Field11 != nil") + } else if that1.Field11 != nil { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", *this.Field12, *that1.Field12) + } + } else if this.Field12 != nil { + return fmt.Errorf("this.Field12 == nil && that.Field12 != nil") + } else if that1.Field12 != nil { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return false + } + } else if this.Field8 != nil { + return false + } else if that1.Field8 != nil { + return false + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return false + } + } else if this.Field9 != nil { + return false + } else if that1.Field9 != nil { + return false + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return false + } + } else if this.Field10 != nil { + return false + } else if that1.Field10 != nil { + return false + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return false + } + } else if this.Field11 != nil { + return false + } else if that1.Field11 != nil { + return false + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return false + } + } else if this.Field12 != nil { + return false + } else if that1.Field12 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepNative) + if !ok { + return fmt.Errorf("that is not of type *NidRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepNative) + if !ok { + return fmt.Errorf("that is not of type *NinRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepPackedNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepPackedNative) + if !ok { + return fmt.Errorf("that is not of type *NidRepPackedNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepPackedNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepPackedNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepPackedNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepPackedNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepPackedNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepPackedNative) + if !ok { + return fmt.Errorf("that is not of type *NinRepPackedNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepPackedNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepPackedNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepPackedNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepPackedNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptStruct) + if !ok { + return fmt.Errorf("that is not of type *NidOptStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptStructbut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(&that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(&that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if !this.Field8.Equal(&that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if this.Field2 != that1.Field2 { + return false + } + if !this.Field3.Equal(&that1.Field3) { + return false + } + if !this.Field4.Equal(&that1.Field4) { + return false + } + if this.Field6 != that1.Field6 { + return false + } + if this.Field7 != that1.Field7 { + return false + } + if !this.Field8.Equal(&that1.Field8) { + return false + } + if this.Field13 != that1.Field13 { + return false + } + if this.Field14 != that1.Field14 { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptStruct) + if !ok { + return fmt.Errorf("that is not of type *NinOptStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptStructbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if !this.Field8.Equal(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !this.Field4.Equal(that1.Field4) { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if !this.Field8.Equal(that1.Field8) { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepStruct) + if !ok { + return fmt.Errorf("that is not of type *NidRepStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepStructbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if !this.Field3[i].Equal(&that1.Field3[i]) { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if !this.Field4[i].Equal(&that1.Field4[i]) { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if !this.Field8[i].Equal(&that1.Field8[i]) { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if !this.Field3[i].Equal(&that1.Field3[i]) { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if !this.Field4[i].Equal(&that1.Field4[i]) { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if !this.Field8[i].Equal(&that1.Field8[i]) { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepStruct) + if !ok { + return fmt.Errorf("that is not of type *NinRepStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepStructbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if !this.Field3[i].Equal(that1.Field3[i]) { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if !this.Field4[i].Equal(that1.Field4[i]) { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if !this.Field8[i].Equal(that1.Field8[i]) { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if !this.Field3[i].Equal(that1.Field3[i]) { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if !this.Field4[i].Equal(that1.Field4[i]) { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if !this.Field8[i].Equal(that1.Field8[i]) { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidEmbeddedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidEmbeddedStruct) + if !ok { + return fmt.Errorf("that is not of type *NidEmbeddedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidEmbeddedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidEmbeddedStructbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(&that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidEmbeddedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidEmbeddedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(&that1.Field200) { + return false + } + if this.Field210 != that1.Field210 { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinEmbeddedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinEmbeddedStruct) + if !ok { + return fmt.Errorf("that is not of type *NinEmbeddedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinEmbeddedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinEmbeddedStructbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", *this.Field210, *that1.Field210) + } + } else if this.Field210 != nil { + return fmt.Errorf("this.Field210 == nil && that.Field210 != nil") + } else if that1.Field210 != nil { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinEmbeddedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinEmbeddedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(that1.Field200) { + return false + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return false + } + } else if this.Field210 != nil { + return false + } else if that1.Field210 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidNestedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidNestedStruct) + if !ok { + return fmt.Errorf("that is not of type *NidNestedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidNestedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidNestedStructbut is not nil && this == nil") + } + if !this.Field1.Equal(&that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if !this.Field2[i].Equal(&that1.Field2[i]) { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidNestedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidNestedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(&that1.Field1) { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if !this.Field2[i].Equal(&that1.Field2[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinNestedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinNestedStruct) + if !ok { + return fmt.Errorf("that is not of type *NinNestedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinNestedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinNestedStructbut is not nil && this == nil") + } + if !this.Field1.Equal(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if !this.Field2[i].Equal(that1.Field2[i]) { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinNestedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinNestedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(that1.Field1) { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if !this.Field2[i].Equal(that1.Field2[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptCustom) + if !ok { + return fmt.Errorf("that is not of type *NidOptCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptCustombut is not nil && this == nil") + } + if !this.Id.Equal(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id) + } + if !this.Value.Equal(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Id.Equal(that1.Id) { + return false + } + if !this.Value.Equal(that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomDash) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomDash) + if !ok { + return fmt.Errorf("that is not of type *CustomDash") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomDash but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomDashbut is not nil && this == nil") + } + if that1.Value == nil { + if this.Value != nil { + return fmt.Errorf("this.Value != nil && that1.Value == nil") + } + } else if !this.Value.Equal(*that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomDash) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomDash) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Value == nil { + if this.Value != nil { + return false + } + } else if !this.Value.Equal(*that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptCustom) + if !ok { + return fmt.Errorf("that is not of type *NinOptCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptCustombut is not nil && this == nil") + } + if that1.Id == nil { + if this.Id != nil { + return fmt.Errorf("this.Id != nil && that1.Id == nil") + } + } else if !this.Id.Equal(*that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id) + } + if that1.Value == nil { + if this.Value != nil { + return fmt.Errorf("this.Value != nil && that1.Value == nil") + } + } else if !this.Value.Equal(*that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Id == nil { + if this.Id != nil { + return false + } + } else if !this.Id.Equal(*that1.Id) { + return false + } + if that1.Value == nil { + if this.Value != nil { + return false + } + } else if !this.Value.Equal(*that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepCustom) + if !ok { + return fmt.Errorf("that is not of type *NidRepCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepCustombut is not nil && this == nil") + } + if len(this.Id) != len(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", len(this.Id), len(that1.Id)) + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return fmt.Errorf("Id this[%v](%v) Not Equal that[%v](%v)", i, this.Id[i], i, that1.Id[i]) + } + } + if len(this.Value) != len(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", len(this.Value), len(that1.Value)) + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return fmt.Errorf("Value this[%v](%v) Not Equal that[%v](%v)", i, this.Value[i], i, that1.Value[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Id) != len(that1.Id) { + return false + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return false + } + } + if len(this.Value) != len(that1.Value) { + return false + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepCustom) + if !ok { + return fmt.Errorf("that is not of type *NinRepCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepCustombut is not nil && this == nil") + } + if len(this.Id) != len(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", len(this.Id), len(that1.Id)) + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return fmt.Errorf("Id this[%v](%v) Not Equal that[%v](%v)", i, this.Id[i], i, that1.Id[i]) + } + } + if len(this.Value) != len(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", len(this.Value), len(that1.Value)) + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return fmt.Errorf("Value this[%v](%v) Not Equal that[%v](%v)", i, this.Value[i], i, that1.Value[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Id) != len(that1.Id) { + return false + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return false + } + } + if len(this.Value) != len(that1.Value) { + return false + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNativeUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNativeUnion) + if !ok { + return fmt.Errorf("that is not of type *NinOptNativeUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNativeUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativeUnionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNativeUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNativeUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinOptStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptStructUnionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !this.Field4.Equal(that1.Field4) { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinEmbeddedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinEmbeddedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinEmbeddedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinEmbeddedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinEmbeddedStructUnionbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", *this.Field210, *that1.Field210) + } + } else if this.Field210 != nil { + return fmt.Errorf("this.Field210 == nil && that.Field210 != nil") + } else if that1.Field210 != nil { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinEmbeddedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinEmbeddedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(that1.Field200) { + return false + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return false + } + } else if this.Field210 != nil { + return false + } else if that1.Field210 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinNestedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinNestedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinNestedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinNestedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinNestedStructUnionbut is not nil && this == nil") + } + if !this.Field1.Equal(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !this.Field2.Equal(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinNestedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinNestedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(that1.Field1) { + return false + } + if !this.Field2.Equal(that1.Field2) { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Tree) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Tree) + if !ok { + return fmt.Errorf("that is not of type *Tree") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Tree but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Treebut is not nil && this == nil") + } + if !this.Or.Equal(that1.Or) { + return fmt.Errorf("Or this(%v) Not Equal that(%v)", this.Or, that1.Or) + } + if !this.And.Equal(that1.And) { + return fmt.Errorf("And this(%v) Not Equal that(%v)", this.And, that1.And) + } + if !this.Leaf.Equal(that1.Leaf) { + return fmt.Errorf("Leaf this(%v) Not Equal that(%v)", this.Leaf, that1.Leaf) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Tree) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Tree) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Or.Equal(that1.Or) { + return false + } + if !this.And.Equal(that1.And) { + return false + } + if !this.Leaf.Equal(that1.Leaf) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OrBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OrBranch) + if !ok { + return fmt.Errorf("that is not of type *OrBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OrBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OrBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OrBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OrBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AndBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AndBranch) + if !ok { + return fmt.Errorf("that is not of type *AndBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AndBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AndBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AndBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AndBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Leaf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Leaf) + if !ok { + return fmt.Errorf("that is not of type *Leaf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Leaf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Leafbut is not nil && this == nil") + } + if this.Value != that1.Value { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if this.StrValue != that1.StrValue { + return fmt.Errorf("StrValue this(%v) Not Equal that(%v)", this.StrValue, that1.StrValue) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Leaf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Leaf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Value != that1.Value { + return false + } + if this.StrValue != that1.StrValue { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *DeepTree) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*DeepTree) + if !ok { + return fmt.Errorf("that is not of type *DeepTree") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *DeepTree but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *DeepTreebut is not nil && this == nil") + } + if !this.Down.Equal(that1.Down) { + return fmt.Errorf("Down this(%v) Not Equal that(%v)", this.Down, that1.Down) + } + if !this.And.Equal(that1.And) { + return fmt.Errorf("And this(%v) Not Equal that(%v)", this.And, that1.And) + } + if !this.Leaf.Equal(that1.Leaf) { + return fmt.Errorf("Leaf this(%v) Not Equal that(%v)", this.Leaf, that1.Leaf) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *DeepTree) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*DeepTree) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Down.Equal(that1.Down) { + return false + } + if !this.And.Equal(that1.And) { + return false + } + if !this.Leaf.Equal(that1.Leaf) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *ADeepBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*ADeepBranch) + if !ok { + return fmt.Errorf("that is not of type *ADeepBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *ADeepBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *ADeepBranchbut is not nil && this == nil") + } + if !this.Down.Equal(&that1.Down) { + return fmt.Errorf("Down this(%v) Not Equal that(%v)", this.Down, that1.Down) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *ADeepBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*ADeepBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Down.Equal(&that1.Down) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AndDeepBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AndDeepBranch) + if !ok { + return fmt.Errorf("that is not of type *AndDeepBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AndDeepBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AndDeepBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AndDeepBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AndDeepBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *DeepLeaf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*DeepLeaf) + if !ok { + return fmt.Errorf("that is not of type *DeepLeaf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *DeepLeaf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *DeepLeafbut is not nil && this == nil") + } + if !this.Tree.Equal(&that1.Tree) { + return fmt.Errorf("Tree this(%v) Not Equal that(%v)", this.Tree, that1.Tree) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *DeepLeaf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*DeepLeaf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Tree.Equal(&that1.Tree) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Nil) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Nil) + if !ok { + return fmt.Errorf("that is not of type *Nil") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Nil but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Nilbut is not nil && this == nil") + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Nil) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Nil) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptEnum) + if !ok { + return fmt.Errorf("that is not of type *NidOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptEnumbut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptEnum) + if !ok { + return fmt.Errorf("that is not of type *NinOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptEnumbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepEnum) + if !ok { + return fmt.Errorf("that is not of type *NidRepEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepEnumbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepEnum) + if !ok { + return fmt.Errorf("that is not of type *NinRepEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepEnumbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptEnumDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptEnumDefault) + if !ok { + return fmt.Errorf("that is not of type *NinOptEnumDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptEnumDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptEnumDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptEnumDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptEnumDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AnotherNinOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AnotherNinOptEnum) + if !ok { + return fmt.Errorf("that is not of type *AnotherNinOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AnotherNinOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AnotherNinOptEnumbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AnotherNinOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AnotherNinOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AnotherNinOptEnumDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AnotherNinOptEnumDefault) + if !ok { + return fmt.Errorf("that is not of type *AnotherNinOptEnumDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AnotherNinOptEnumDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AnotherNinOptEnumDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AnotherNinOptEnumDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AnotherNinOptEnumDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Timer) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Timer) + if !ok { + return fmt.Errorf("that is not of type *Timer") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Timer but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Timerbut is not nil && this == nil") + } + if this.Time1 != that1.Time1 { + return fmt.Errorf("Time1 this(%v) Not Equal that(%v)", this.Time1, that1.Time1) + } + if this.Time2 != that1.Time2 { + return fmt.Errorf("Time2 this(%v) Not Equal that(%v)", this.Time2, that1.Time2) + } + if !bytes.Equal(this.Data, that1.Data) { + return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Timer) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Timer) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Time1 != that1.Time1 { + return false + } + if this.Time2 != that1.Time2 { + return false + } + if !bytes.Equal(this.Data, that1.Data) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *MyExtendable) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*MyExtendable) + if !ok { + return fmt.Errorf("that is not of type *MyExtendable") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *MyExtendable but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *MyExtendablebut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return fmt.Errorf("XXX_extensions this[%v](%v) Not Equal that[%v](%v)", k, this.XXX_extensions[k], k, that1.XXX_extensions[k]) + } + } else { + return fmt.Errorf("XXX_extensions[%v] Not In that", k) + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return fmt.Errorf("XXX_extensions[%v] Not In this", k) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *MyExtendable) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*MyExtendable) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return false + } + } else { + return false + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OtherExtenable) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OtherExtenable) + if !ok { + return fmt.Errorf("that is not of type *OtherExtenable") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OtherExtenable but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OtherExtenablebut is not nil && this == nil") + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if !this.M.Equal(that1.M) { + return fmt.Errorf("M this(%v) Not Equal that(%v)", this.M, that1.M) + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return fmt.Errorf("XXX_extensions this[%v](%v) Not Equal that[%v](%v)", k, this.XXX_extensions[k], k, that1.XXX_extensions[k]) + } + } else { + return fmt.Errorf("XXX_extensions[%v] Not In that", k) + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return fmt.Errorf("XXX_extensions[%v] Not In this", k) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OtherExtenable) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OtherExtenable) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if !this.M.Equal(that1.M) { + return false + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return false + } + } else { + return false + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinitionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.EnumField != nil && that1.EnumField != nil { + if *this.EnumField != *that1.EnumField { + return fmt.Errorf("EnumField this(%v) Not Equal that(%v)", *this.EnumField, *that1.EnumField) + } + } else if this.EnumField != nil { + return fmt.Errorf("this.EnumField == nil && that.EnumField != nil") + } else if that1.EnumField != nil { + return fmt.Errorf("EnumField this(%v) Not Equal that(%v)", this.EnumField, that1.EnumField) + } + if !this.NNM.Equal(that1.NNM) { + return fmt.Errorf("NNM this(%v) Not Equal that(%v)", this.NNM, that1.NNM) + } + if !this.NM.Equal(that1.NM) { + return fmt.Errorf("NM this(%v) Not Equal that(%v)", this.NM, that1.NM) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.EnumField != nil && that1.EnumField != nil { + if *this.EnumField != *that1.EnumField { + return false + } + } else if this.EnumField != nil { + return false + } else if that1.EnumField != nil { + return false + } + if !this.NNM.Equal(that1.NNM) { + return false + } + if !this.NM.Equal(that1.NM) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition_NestedMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition_NestedMessage) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition_NestedMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition_NestedMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinition_NestedMessagebut is not nil && this == nil") + } + if this.NestedField1 != nil && that1.NestedField1 != nil { + if *this.NestedField1 != *that1.NestedField1 { + return fmt.Errorf("NestedField1 this(%v) Not Equal that(%v)", *this.NestedField1, *that1.NestedField1) + } + } else if this.NestedField1 != nil { + return fmt.Errorf("this.NestedField1 == nil && that.NestedField1 != nil") + } else if that1.NestedField1 != nil { + return fmt.Errorf("NestedField1 this(%v) Not Equal that(%v)", this.NestedField1, that1.NestedField1) + } + if !this.NNM.Equal(that1.NNM) { + return fmt.Errorf("NNM this(%v) Not Equal that(%v)", this.NNM, that1.NNM) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition_NestedMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition_NestedMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.NestedField1 != nil && that1.NestedField1 != nil { + if *this.NestedField1 != *that1.NestedField1 { + return false + } + } else if this.NestedField1 != nil { + return false + } else if that1.NestedField1 != nil { + return false + } + if !this.NNM.Equal(that1.NNM) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition_NestedMessage_NestedNestedMsg) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition_NestedMessage_NestedNestedMsg") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition_NestedMessage_NestedNestedMsg but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinition_NestedMessage_NestedNestedMsgbut is not nil && this == nil") + } + if this.NestedNestedField1 != nil && that1.NestedNestedField1 != nil { + if *this.NestedNestedField1 != *that1.NestedNestedField1 { + return fmt.Errorf("NestedNestedField1 this(%v) Not Equal that(%v)", *this.NestedNestedField1, *that1.NestedNestedField1) + } + } else if this.NestedNestedField1 != nil { + return fmt.Errorf("this.NestedNestedField1 == nil && that.NestedNestedField1 != nil") + } else if that1.NestedNestedField1 != nil { + return fmt.Errorf("NestedNestedField1 this(%v) Not Equal that(%v)", this.NestedNestedField1, that1.NestedNestedField1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition_NestedMessage_NestedNestedMsg) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.NestedNestedField1 != nil && that1.NestedNestedField1 != nil { + if *this.NestedNestedField1 != *that1.NestedNestedField1 { + return false + } + } else if this.NestedNestedField1 != nil { + return false + } else if that1.NestedNestedField1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedScope) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedScope) + if !ok { + return fmt.Errorf("that is not of type *NestedScope") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedScope but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedScopebut is not nil && this == nil") + } + if !this.A.Equal(that1.A) { + return fmt.Errorf("A this(%v) Not Equal that(%v)", this.A, that1.A) + } + if this.B != nil && that1.B != nil { + if *this.B != *that1.B { + return fmt.Errorf("B this(%v) Not Equal that(%v)", *this.B, *that1.B) + } + } else if this.B != nil { + return fmt.Errorf("this.B == nil && that.B != nil") + } else if that1.B != nil { + return fmt.Errorf("B this(%v) Not Equal that(%v)", this.B, that1.B) + } + if !this.C.Equal(that1.C) { + return fmt.Errorf("C this(%v) Not Equal that(%v)", this.C, that1.C) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedScope) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedScope) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.A.Equal(that1.A) { + return false + } + if this.B != nil && that1.B != nil { + if *this.B != *that1.B { + return false + } + } else if this.B != nil { + return false + } else if that1.B != nil { + return false + } + if !this.C.Equal(that1.C) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNativeDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNativeDefault) + if !ok { + return fmt.Errorf("that is not of type *NinOptNativeDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNativeDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativeDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", *this.Field8, *that1.Field8) + } + } else if this.Field8 != nil { + return fmt.Errorf("this.Field8 == nil && that.Field8 != nil") + } else if that1.Field8 != nil { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", *this.Field9, *that1.Field9) + } + } else if this.Field9 != nil { + return fmt.Errorf("this.Field9 == nil && that.Field9 != nil") + } else if that1.Field9 != nil { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", *this.Field10, *that1.Field10) + } + } else if this.Field10 != nil { + return fmt.Errorf("this.Field10 == nil && that.Field10 != nil") + } else if that1.Field10 != nil { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", *this.Field11, *that1.Field11) + } + } else if this.Field11 != nil { + return fmt.Errorf("this.Field11 == nil && that.Field11 != nil") + } else if that1.Field11 != nil { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", *this.Field12, *that1.Field12) + } + } else if this.Field12 != nil { + return fmt.Errorf("this.Field12 == nil && that.Field12 != nil") + } else if that1.Field12 != nil { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNativeDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNativeDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return false + } + } else if this.Field8 != nil { + return false + } else if that1.Field8 != nil { + return false + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return false + } + } else if this.Field9 != nil { + return false + } else if that1.Field9 != nil { + return false + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return false + } + } else if this.Field10 != nil { + return false + } else if that1.Field10 != nil { + return false + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return false + } + } else if this.Field11 != nil { + return false + } else if that1.Field11 != nil { + return false + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return false + } + } else if this.Field12 != nil { + return false + } else if that1.Field12 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomContainer) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomContainer) + if !ok { + return fmt.Errorf("that is not of type *CustomContainer") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomContainer but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomContainerbut is not nil && this == nil") + } + if !this.CustomStruct.Equal(&that1.CustomStruct) { + return fmt.Errorf("CustomStruct this(%v) Not Equal that(%v)", this.CustomStruct, that1.CustomStruct) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomContainer) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomContainer) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.CustomStruct.Equal(&that1.CustomStruct) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNidOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNidOptNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNidOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNidOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNidOptNativebut is not nil && this == nil") + } + if this.FieldA != that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if this.FieldC != that1.FieldC { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if this.FieldD != that1.FieldD { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", this.FieldD, that1.FieldD) + } + if this.FieldE != that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if this.FieldG != that1.FieldG { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if this.FieldJ != that1.FieldJ { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if this.FieldK != that1.FieldK { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", this.FieldK, that1.FieldK) + } + if this.FieldL != that1.FieldL { + return fmt.Errorf("FieldL this(%v) Not Equal that(%v)", this.FieldL, that1.FieldL) + } + if this.FieldM != that1.FieldM { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", this.FieldM, that1.FieldM) + } + if this.FieldN != that1.FieldN { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", this.FieldN, that1.FieldN) + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", this.FieldO, that1.FieldO) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNidOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNidOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != that1.FieldA { + return false + } + if this.FieldB != that1.FieldB { + return false + } + if this.FieldC != that1.FieldC { + return false + } + if this.FieldD != that1.FieldD { + return false + } + if this.FieldE != that1.FieldE { + return false + } + if this.FieldF != that1.FieldF { + return false + } + if this.FieldG != that1.FieldG { + return false + } + if this.FieldH != that1.FieldH { + return false + } + if this.FieldI != that1.FieldI { + return false + } + if this.FieldJ != that1.FieldJ { + return false + } + if this.FieldK != that1.FieldK { + return false + } + if this.FieldL != that1.FieldL { + return false + } + if this.FieldM != that1.FieldM { + return false + } + if this.FieldN != that1.FieldN { + return false + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinOptNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinOptNativebut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if this.FieldC != nil && that1.FieldC != nil { + if *this.FieldC != *that1.FieldC { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", *this.FieldC, *that1.FieldC) + } + } else if this.FieldC != nil { + return fmt.Errorf("this.FieldC == nil && that.FieldC != nil") + } else if that1.FieldC != nil { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if this.FieldD != nil && that1.FieldD != nil { + if *this.FieldD != *that1.FieldD { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", *this.FieldD, *that1.FieldD) + } + } else if this.FieldD != nil { + return fmt.Errorf("this.FieldD == nil && that.FieldD != nil") + } else if that1.FieldD != nil { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", this.FieldD, that1.FieldD) + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", *this.FieldE, *that1.FieldE) + } + } else if this.FieldE != nil { + return fmt.Errorf("this.FieldE == nil && that.FieldE != nil") + } else if that1.FieldE != nil { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", *this.FieldF, *that1.FieldF) + } + } else if this.FieldF != nil { + return fmt.Errorf("this.FieldF == nil && that.FieldF != nil") + } else if that1.FieldF != nil { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if this.FieldG != nil && that1.FieldG != nil { + if *this.FieldG != *that1.FieldG { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", *this.FieldG, *that1.FieldG) + } + } else if this.FieldG != nil { + return fmt.Errorf("this.FieldG == nil && that.FieldG != nil") + } else if that1.FieldG != nil { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", *this.FieldH, *that1.FieldH) + } + } else if this.FieldH != nil { + return fmt.Errorf("this.FieldH == nil && that.FieldH != nil") + } else if that1.FieldH != nil { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", *this.FieldI, *that1.FieldI) + } + } else if this.FieldI != nil { + return fmt.Errorf("this.FieldI == nil && that.FieldI != nil") + } else if that1.FieldI != nil { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if this.FieldJ != nil && that1.FieldJ != nil { + if *this.FieldJ != *that1.FieldJ { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", *this.FieldJ, *that1.FieldJ) + } + } else if this.FieldJ != nil { + return fmt.Errorf("this.FieldJ == nil && that.FieldJ != nil") + } else if that1.FieldJ != nil { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if this.FieldK != nil && that1.FieldK != nil { + if *this.FieldK != *that1.FieldK { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", *this.FieldK, *that1.FieldK) + } + } else if this.FieldK != nil { + return fmt.Errorf("this.FieldK == nil && that.FieldK != nil") + } else if that1.FieldK != nil { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", this.FieldK, that1.FieldK) + } + if this.FielL != nil && that1.FielL != nil { + if *this.FielL != *that1.FielL { + return fmt.Errorf("FielL this(%v) Not Equal that(%v)", *this.FielL, *that1.FielL) + } + } else if this.FielL != nil { + return fmt.Errorf("this.FielL == nil && that.FielL != nil") + } else if that1.FielL != nil { + return fmt.Errorf("FielL this(%v) Not Equal that(%v)", this.FielL, that1.FielL) + } + if this.FieldM != nil && that1.FieldM != nil { + if *this.FieldM != *that1.FieldM { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", *this.FieldM, *that1.FieldM) + } + } else if this.FieldM != nil { + return fmt.Errorf("this.FieldM == nil && that.FieldM != nil") + } else if that1.FieldM != nil { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", this.FieldM, that1.FieldM) + } + if this.FieldN != nil && that1.FieldN != nil { + if *this.FieldN != *that1.FieldN { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", *this.FieldN, *that1.FieldN) + } + } else if this.FieldN != nil { + return fmt.Errorf("this.FieldN == nil && that.FieldN != nil") + } else if that1.FieldN != nil { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", this.FieldN, that1.FieldN) + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", this.FieldO, that1.FieldO) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if this.FieldC != nil && that1.FieldC != nil { + if *this.FieldC != *that1.FieldC { + return false + } + } else if this.FieldC != nil { + return false + } else if that1.FieldC != nil { + return false + } + if this.FieldD != nil && that1.FieldD != nil { + if *this.FieldD != *that1.FieldD { + return false + } + } else if this.FieldD != nil { + return false + } else if that1.FieldD != nil { + return false + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return false + } + } else if this.FieldE != nil { + return false + } else if that1.FieldE != nil { + return false + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return false + } + } else if this.FieldF != nil { + return false + } else if that1.FieldF != nil { + return false + } + if this.FieldG != nil && that1.FieldG != nil { + if *this.FieldG != *that1.FieldG { + return false + } + } else if this.FieldG != nil { + return false + } else if that1.FieldG != nil { + return false + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return false + } + } else if this.FieldH != nil { + return false + } else if that1.FieldH != nil { + return false + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return false + } + } else if this.FieldI != nil { + return false + } else if that1.FieldI != nil { + return false + } + if this.FieldJ != nil && that1.FieldJ != nil { + if *this.FieldJ != *that1.FieldJ { + return false + } + } else if this.FieldJ != nil { + return false + } else if that1.FieldJ != nil { + return false + } + if this.FieldK != nil && that1.FieldK != nil { + if *this.FieldK != *that1.FieldK { + return false + } + } else if this.FieldK != nil { + return false + } else if that1.FieldK != nil { + return false + } + if this.FielL != nil && that1.FielL != nil { + if *this.FielL != *that1.FielL { + return false + } + } else if this.FielL != nil { + return false + } else if that1.FielL != nil { + return false + } + if this.FieldM != nil && that1.FieldM != nil { + if *this.FieldM != *that1.FieldM { + return false + } + } else if this.FieldM != nil { + return false + } else if that1.FieldM != nil { + return false + } + if this.FieldN != nil && that1.FieldN != nil { + if *this.FieldN != *that1.FieldN { + return false + } + } else if this.FieldN != nil { + return false + } else if that1.FieldN != nil { + return false + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinRepNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinRepNativebut is not nil && this == nil") + } + if len(this.FieldA) != len(that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", len(this.FieldA), len(that1.FieldA)) + } + for i := range this.FieldA { + if this.FieldA[i] != that1.FieldA[i] { + return fmt.Errorf("FieldA this[%v](%v) Not Equal that[%v](%v)", i, this.FieldA[i], i, that1.FieldA[i]) + } + } + if len(this.FieldB) != len(that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", len(this.FieldB), len(that1.FieldB)) + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return fmt.Errorf("FieldB this[%v](%v) Not Equal that[%v](%v)", i, this.FieldB[i], i, that1.FieldB[i]) + } + } + if len(this.FieldC) != len(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", len(this.FieldC), len(that1.FieldC)) + } + for i := range this.FieldC { + if this.FieldC[i] != that1.FieldC[i] { + return fmt.Errorf("FieldC this[%v](%v) Not Equal that[%v](%v)", i, this.FieldC[i], i, that1.FieldC[i]) + } + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if this.FieldD[i] != that1.FieldD[i] { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if len(this.FieldE) != len(that1.FieldE) { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", len(this.FieldE), len(that1.FieldE)) + } + for i := range this.FieldE { + if this.FieldE[i] != that1.FieldE[i] { + return fmt.Errorf("FieldE this[%v](%v) Not Equal that[%v](%v)", i, this.FieldE[i], i, that1.FieldE[i]) + } + } + if len(this.FieldF) != len(that1.FieldF) { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", len(this.FieldF), len(that1.FieldF)) + } + for i := range this.FieldF { + if this.FieldF[i] != that1.FieldF[i] { + return fmt.Errorf("FieldF this[%v](%v) Not Equal that[%v](%v)", i, this.FieldF[i], i, that1.FieldF[i]) + } + } + if len(this.FieldG) != len(that1.FieldG) { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", len(this.FieldG), len(that1.FieldG)) + } + for i := range this.FieldG { + if this.FieldG[i] != that1.FieldG[i] { + return fmt.Errorf("FieldG this[%v](%v) Not Equal that[%v](%v)", i, this.FieldG[i], i, that1.FieldG[i]) + } + } + if len(this.FieldH) != len(that1.FieldH) { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", len(this.FieldH), len(that1.FieldH)) + } + for i := range this.FieldH { + if this.FieldH[i] != that1.FieldH[i] { + return fmt.Errorf("FieldH this[%v](%v) Not Equal that[%v](%v)", i, this.FieldH[i], i, that1.FieldH[i]) + } + } + if len(this.FieldI) != len(that1.FieldI) { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", len(this.FieldI), len(that1.FieldI)) + } + for i := range this.FieldI { + if this.FieldI[i] != that1.FieldI[i] { + return fmt.Errorf("FieldI this[%v](%v) Not Equal that[%v](%v)", i, this.FieldI[i], i, that1.FieldI[i]) + } + } + if len(this.FieldJ) != len(that1.FieldJ) { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", len(this.FieldJ), len(that1.FieldJ)) + } + for i := range this.FieldJ { + if this.FieldJ[i] != that1.FieldJ[i] { + return fmt.Errorf("FieldJ this[%v](%v) Not Equal that[%v](%v)", i, this.FieldJ[i], i, that1.FieldJ[i]) + } + } + if len(this.FieldK) != len(that1.FieldK) { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", len(this.FieldK), len(that1.FieldK)) + } + for i := range this.FieldK { + if this.FieldK[i] != that1.FieldK[i] { + return fmt.Errorf("FieldK this[%v](%v) Not Equal that[%v](%v)", i, this.FieldK[i], i, that1.FieldK[i]) + } + } + if len(this.FieldL) != len(that1.FieldL) { + return fmt.Errorf("FieldL this(%v) Not Equal that(%v)", len(this.FieldL), len(that1.FieldL)) + } + for i := range this.FieldL { + if this.FieldL[i] != that1.FieldL[i] { + return fmt.Errorf("FieldL this[%v](%v) Not Equal that[%v](%v)", i, this.FieldL[i], i, that1.FieldL[i]) + } + } + if len(this.FieldM) != len(that1.FieldM) { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", len(this.FieldM), len(that1.FieldM)) + } + for i := range this.FieldM { + if this.FieldM[i] != that1.FieldM[i] { + return fmt.Errorf("FieldM this[%v](%v) Not Equal that[%v](%v)", i, this.FieldM[i], i, that1.FieldM[i]) + } + } + if len(this.FieldN) != len(that1.FieldN) { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", len(this.FieldN), len(that1.FieldN)) + } + for i := range this.FieldN { + if this.FieldN[i] != that1.FieldN[i] { + return fmt.Errorf("FieldN this[%v](%v) Not Equal that[%v](%v)", i, this.FieldN[i], i, that1.FieldN[i]) + } + } + if len(this.FieldO) != len(that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", len(this.FieldO), len(that1.FieldO)) + } + for i := range this.FieldO { + if !bytes.Equal(this.FieldO[i], that1.FieldO[i]) { + return fmt.Errorf("FieldO this[%v](%v) Not Equal that[%v](%v)", i, this.FieldO[i], i, that1.FieldO[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.FieldA) != len(that1.FieldA) { + return false + } + for i := range this.FieldA { + if this.FieldA[i] != that1.FieldA[i] { + return false + } + } + if len(this.FieldB) != len(that1.FieldB) { + return false + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return false + } + } + if len(this.FieldC) != len(that1.FieldC) { + return false + } + for i := range this.FieldC { + if this.FieldC[i] != that1.FieldC[i] { + return false + } + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if this.FieldD[i] != that1.FieldD[i] { + return false + } + } + if len(this.FieldE) != len(that1.FieldE) { + return false + } + for i := range this.FieldE { + if this.FieldE[i] != that1.FieldE[i] { + return false + } + } + if len(this.FieldF) != len(that1.FieldF) { + return false + } + for i := range this.FieldF { + if this.FieldF[i] != that1.FieldF[i] { + return false + } + } + if len(this.FieldG) != len(that1.FieldG) { + return false + } + for i := range this.FieldG { + if this.FieldG[i] != that1.FieldG[i] { + return false + } + } + if len(this.FieldH) != len(that1.FieldH) { + return false + } + for i := range this.FieldH { + if this.FieldH[i] != that1.FieldH[i] { + return false + } + } + if len(this.FieldI) != len(that1.FieldI) { + return false + } + for i := range this.FieldI { + if this.FieldI[i] != that1.FieldI[i] { + return false + } + } + if len(this.FieldJ) != len(that1.FieldJ) { + return false + } + for i := range this.FieldJ { + if this.FieldJ[i] != that1.FieldJ[i] { + return false + } + } + if len(this.FieldK) != len(that1.FieldK) { + return false + } + for i := range this.FieldK { + if this.FieldK[i] != that1.FieldK[i] { + return false + } + } + if len(this.FieldL) != len(that1.FieldL) { + return false + } + for i := range this.FieldL { + if this.FieldL[i] != that1.FieldL[i] { + return false + } + } + if len(this.FieldM) != len(that1.FieldM) { + return false + } + for i := range this.FieldM { + if this.FieldM[i] != that1.FieldM[i] { + return false + } + } + if len(this.FieldN) != len(that1.FieldN) { + return false + } + for i := range this.FieldN { + if this.FieldN[i] != that1.FieldN[i] { + return false + } + } + if len(this.FieldO) != len(that1.FieldO) { + return false + } + for i := range this.FieldO { + if !bytes.Equal(this.FieldO[i], that1.FieldO[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinStruct) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinStructbut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if !this.FieldC.Equal(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", *this.FieldE, *that1.FieldE) + } + } else if this.FieldE != nil { + return fmt.Errorf("this.FieldE == nil && that.FieldE != nil") + } else if that1.FieldE != nil { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", *this.FieldF, *that1.FieldF) + } + } else if this.FieldF != nil { + return fmt.Errorf("this.FieldF == nil && that.FieldF != nil") + } else if that1.FieldF != nil { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if !this.FieldG.Equal(that1.FieldG) { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", *this.FieldH, *that1.FieldH) + } + } else if this.FieldH != nil { + return fmt.Errorf("this.FieldH == nil && that.FieldH != nil") + } else if that1.FieldH != nil { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", *this.FieldI, *that1.FieldI) + } + } else if this.FieldI != nil { + return fmt.Errorf("this.FieldI == nil && that.FieldI != nil") + } else if that1.FieldI != nil { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if !bytes.Equal(this.FieldJ, that1.FieldJ) { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if !this.FieldC.Equal(that1.FieldC) { + return false + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return false + } + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return false + } + } else if this.FieldE != nil { + return false + } else if that1.FieldE != nil { + return false + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return false + } + } else if this.FieldF != nil { + return false + } else if that1.FieldF != nil { + return false + } + if !this.FieldG.Equal(that1.FieldG) { + return false + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return false + } + } else if this.FieldH != nil { + return false + } else if that1.FieldH != nil { + return false + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return false + } + } else if this.FieldI != nil { + return false + } else if that1.FieldI != nil { + return false + } + if !bytes.Equal(this.FieldJ, that1.FieldJ) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameCustomType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameCustomType) + if !ok { + return fmt.Errorf("that is not of type *CustomNameCustomType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameCustomType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameCustomTypebut is not nil && this == nil") + } + if that1.FieldA == nil { + if this.FieldA != nil { + return fmt.Errorf("this.FieldA != nil && that1.FieldA == nil") + } + } else if !this.FieldA.Equal(*that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if that1.FieldB == nil { + if this.FieldB != nil { + return fmt.Errorf("this.FieldB != nil && that1.FieldB == nil") + } + } else if !this.FieldB.Equal(*that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if len(this.FieldC) != len(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", len(this.FieldC), len(that1.FieldC)) + } + for i := range this.FieldC { + if !this.FieldC[i].Equal(that1.FieldC[i]) { + return fmt.Errorf("FieldC this[%v](%v) Not Equal that[%v](%v)", i, this.FieldC[i], i, that1.FieldC[i]) + } + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameCustomType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameCustomType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.FieldA == nil { + if this.FieldA != nil { + return false + } + } else if !this.FieldA.Equal(*that1.FieldA) { + return false + } + if that1.FieldB == nil { + if this.FieldB != nil { + return false + } + } else if !this.FieldB.Equal(*that1.FieldB) { + return false + } + if len(this.FieldC) != len(that1.FieldC) { + return false + } + for i := range this.FieldC { + if !this.FieldC[i].Equal(that1.FieldC[i]) { + return false + } + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinEmbeddedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinEmbeddedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinEmbeddedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinEmbeddedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinEmbeddedStructUnionbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.FieldA.Equal(that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinEmbeddedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinEmbeddedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.FieldA.Equal(that1.FieldA) { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameEnum) + if !ok { + return fmt.Errorf("that is not of type *CustomNameEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameEnumbut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if len(this.FieldB) != len(that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", len(this.FieldB), len(that1.FieldB)) + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return fmt.Errorf("FieldB this[%v](%v) Not Equal that[%v](%v)", i, this.FieldB[i], i, that1.FieldB[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if len(this.FieldB) != len(that1.FieldB) { + return false + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NoExtensionsMap) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NoExtensionsMap) + if !ok { + return fmt.Errorf("that is not of type *NoExtensionsMap") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NoExtensionsMap but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NoExtensionsMapbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) { + return fmt.Errorf("XXX_extensions this(%v) Not Equal that(%v)", this.XXX_extensions, that1.XXX_extensions) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NoExtensionsMap) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NoExtensionsMap) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Unrecognized) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Unrecognized) + if !ok { + return fmt.Errorf("that is not of type *Unrecognized") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Unrecognized but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Unrecognizedbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *Unrecognized) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Unrecognized) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} +func (this *UnrecognizedWithInner) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithInner) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithInner") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithInner but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithInnerbut is not nil && this == nil") + } + if len(this.Embedded) != len(that1.Embedded) { + return fmt.Errorf("Embedded this(%v) Not Equal that(%v)", len(this.Embedded), len(that1.Embedded)) + } + for i := range this.Embedded { + if !this.Embedded[i].Equal(that1.Embedded[i]) { + return fmt.Errorf("Embedded this[%v](%v) Not Equal that[%v](%v)", i, this.Embedded[i], i, that1.Embedded[i]) + } + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *UnrecognizedWithInner) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithInner) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Embedded) != len(that1.Embedded) { + return false + } + for i := range this.Embedded { + if !this.Embedded[i].Equal(that1.Embedded[i]) { + return false + } + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *UnrecognizedWithInner_Inner) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithInner_Inner) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithInner_Inner") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithInner_Inner but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithInner_Innerbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *UnrecognizedWithInner_Inner) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithInner_Inner) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} +func (this *UnrecognizedWithEmbed) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithEmbed) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithEmbed") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithEmbed but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithEmbedbut is not nil && this == nil") + } + if !this.UnrecognizedWithEmbed_Embedded.Equal(&that1.UnrecognizedWithEmbed_Embedded) { + return fmt.Errorf("UnrecognizedWithEmbed_Embedded this(%v) Not Equal that(%v)", this.UnrecognizedWithEmbed_Embedded, that1.UnrecognizedWithEmbed_Embedded) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *UnrecognizedWithEmbed) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithEmbed) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.UnrecognizedWithEmbed_Embedded.Equal(&that1.UnrecognizedWithEmbed_Embedded) { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *UnrecognizedWithEmbed_Embedded) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithEmbed_Embedded) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithEmbed_Embedded") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithEmbed_Embedded but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithEmbed_Embeddedbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *UnrecognizedWithEmbed_Embedded) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithEmbed_Embedded) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} + +type NidOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() float64 + GetField2() float32 + GetField3() int32 + GetField4() int64 + GetField5() uint32 + GetField6() uint64 + GetField7() int32 + GetField8() int64 + GetField9() uint32 + GetField10() int32 + GetField11() uint64 + GetField12() int64 + GetField13() bool + GetField14() string + GetField15() []byte +} + +func (this *NidOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptNativeFromFace(this) +} + +func (this *NidOptNative) GetField1() float64 { + return this.Field1 +} + +func (this *NidOptNative) GetField2() float32 { + return this.Field2 +} + +func (this *NidOptNative) GetField3() int32 { + return this.Field3 +} + +func (this *NidOptNative) GetField4() int64 { + return this.Field4 +} + +func (this *NidOptNative) GetField5() uint32 { + return this.Field5 +} + +func (this *NidOptNative) GetField6() uint64 { + return this.Field6 +} + +func (this *NidOptNative) GetField7() int32 { + return this.Field7 +} + +func (this *NidOptNative) GetField8() int64 { + return this.Field8 +} + +func (this *NidOptNative) GetField9() uint32 { + return this.Field9 +} + +func (this *NidOptNative) GetField10() int32 { + return this.Field10 +} + +func (this *NidOptNative) GetField11() uint64 { + return this.Field11 +} + +func (this *NidOptNative) GetField12() int64 { + return this.Field12 +} + +func (this *NidOptNative) GetField13() bool { + return this.Field13 +} + +func (this *NidOptNative) GetField14() string { + return this.Field14 +} + +func (this *NidOptNative) GetField15() []byte { + return this.Field15 +} + +func NewNidOptNativeFromFace(that NidOptNativeFace) *NidOptNative { + this := &NidOptNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *int32 + GetField4() *int64 + GetField5() *uint32 + GetField6() *uint64 + GetField7() *int32 + GetField8() *int64 + GetField9() *uint32 + GetField10() *int32 + GetField11() *uint64 + GetField12() *int64 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptNativeFromFace(this) +} + +func (this *NinOptNative) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptNative) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptNative) GetField3() *int32 { + return this.Field3 +} + +func (this *NinOptNative) GetField4() *int64 { + return this.Field4 +} + +func (this *NinOptNative) GetField5() *uint32 { + return this.Field5 +} + +func (this *NinOptNative) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptNative) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptNative) GetField8() *int64 { + return this.Field8 +} + +func (this *NinOptNative) GetField9() *uint32 { + return this.Field9 +} + +func (this *NinOptNative) GetField10() *int32 { + return this.Field10 +} + +func (this *NinOptNative) GetField11() *uint64 { + return this.Field11 +} + +func (this *NinOptNative) GetField12() *int64 { + return this.Field12 +} + +func (this *NinOptNative) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptNative) GetField14() *string { + return this.Field14 +} + +func (this *NinOptNative) GetField15() []byte { + return this.Field15 +} + +func NewNinOptNativeFromFace(that NinOptNativeFace) *NinOptNative { + this := &NinOptNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NidRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepNativeFromFace(this) +} + +func (this *NidRepNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NidRepNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NidRepNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NidRepNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NidRepNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NidRepNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NidRepNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NidRepNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NidRepNative) GetField13() []bool { + return this.Field13 +} + +func (this *NidRepNative) GetField14() []string { + return this.Field14 +} + +func (this *NidRepNative) GetField15() [][]byte { + return this.Field15 +} + +func NewNidRepNativeFromFace(that NidRepNativeFace) *NidRepNative { + this := &NidRepNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NinRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepNativeFromFace(this) +} + +func (this *NinRepNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NinRepNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NinRepNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NinRepNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NinRepNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NinRepNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NinRepNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NinRepNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NinRepNative) GetField13() []bool { + return this.Field13 +} + +func (this *NinRepNative) GetField14() []string { + return this.Field14 +} + +func (this *NinRepNative) GetField15() [][]byte { + return this.Field15 +} + +func NewNinRepNativeFromFace(that NinRepNativeFace) *NinRepNative { + this := &NinRepNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepPackedNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool +} + +func (this *NidRepPackedNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepPackedNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepPackedNativeFromFace(this) +} + +func (this *NidRepPackedNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepPackedNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepPackedNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NidRepPackedNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NidRepPackedNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NidRepPackedNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepPackedNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepPackedNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NidRepPackedNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NidRepPackedNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NidRepPackedNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NidRepPackedNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NidRepPackedNative) GetField13() []bool { + return this.Field13 +} + +func NewNidRepPackedNativeFromFace(that NidRepPackedNativeFace) *NidRepPackedNative { + this := &NidRepPackedNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + return this +} + +type NinRepPackedNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool +} + +func (this *NinRepPackedNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepPackedNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepPackedNativeFromFace(this) +} + +func (this *NinRepPackedNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepPackedNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepPackedNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NinRepPackedNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NinRepPackedNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NinRepPackedNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepPackedNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepPackedNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NinRepPackedNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NinRepPackedNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NinRepPackedNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NinRepPackedNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NinRepPackedNative) GetField13() []bool { + return this.Field13 +} + +func NewNinRepPackedNativeFromFace(that NinRepPackedNativeFace) *NinRepPackedNative { + this := &NinRepPackedNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + return this +} + +type NidOptStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() float64 + GetField2() float32 + GetField3() NidOptNative + GetField4() NinOptNative + GetField6() uint64 + GetField7() int32 + GetField8() NidOptNative + GetField13() bool + GetField14() string + GetField15() []byte +} + +func (this *NidOptStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptStructFromFace(this) +} + +func (this *NidOptStruct) GetField1() float64 { + return this.Field1 +} + +func (this *NidOptStruct) GetField2() float32 { + return this.Field2 +} + +func (this *NidOptStruct) GetField3() NidOptNative { + return this.Field3 +} + +func (this *NidOptStruct) GetField4() NinOptNative { + return this.Field4 +} + +func (this *NidOptStruct) GetField6() uint64 { + return this.Field6 +} + +func (this *NidOptStruct) GetField7() int32 { + return this.Field7 +} + +func (this *NidOptStruct) GetField8() NidOptNative { + return this.Field8 +} + +func (this *NidOptStruct) GetField13() bool { + return this.Field13 +} + +func (this *NidOptStruct) GetField14() string { + return this.Field14 +} + +func (this *NidOptStruct) GetField15() []byte { + return this.Field15 +} + +func NewNidOptStructFromFace(that NidOptStructFace) *NidOptStruct { + this := &NidOptStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *NidOptNative + GetField4() *NinOptNative + GetField6() *uint64 + GetField7() *int32 + GetField8() *NidOptNative + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptStructFromFace(this) +} + +func (this *NinOptStruct) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptStruct) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptStruct) GetField3() *NidOptNative { + return this.Field3 +} + +func (this *NinOptStruct) GetField4() *NinOptNative { + return this.Field4 +} + +func (this *NinOptStruct) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptStruct) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptStruct) GetField8() *NidOptNative { + return this.Field8 +} + +func (this *NinOptStruct) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptStruct) GetField14() *string { + return this.Field14 +} + +func (this *NinOptStruct) GetField15() []byte { + return this.Field15 +} + +func NewNinOptStructFromFace(that NinOptStructFace) *NinOptStruct { + this := &NinOptStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []NidOptNative + GetField4() []NinOptNative + GetField6() []uint64 + GetField7() []int32 + GetField8() []NidOptNative + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NidRepStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepStructFromFace(this) +} + +func (this *NidRepStruct) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepStruct) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepStruct) GetField3() []NidOptNative { + return this.Field3 +} + +func (this *NidRepStruct) GetField4() []NinOptNative { + return this.Field4 +} + +func (this *NidRepStruct) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepStruct) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepStruct) GetField8() []NidOptNative { + return this.Field8 +} + +func (this *NidRepStruct) GetField13() []bool { + return this.Field13 +} + +func (this *NidRepStruct) GetField14() []string { + return this.Field14 +} + +func (this *NidRepStruct) GetField15() [][]byte { + return this.Field15 +} + +func NewNidRepStructFromFace(that NidRepStructFace) *NidRepStruct { + this := &NidRepStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinRepStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []*NidOptNative + GetField4() []*NinOptNative + GetField6() []uint64 + GetField7() []int32 + GetField8() []*NidOptNative + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NinRepStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepStructFromFace(this) +} + +func (this *NinRepStruct) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepStruct) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepStruct) GetField3() []*NidOptNative { + return this.Field3 +} + +func (this *NinRepStruct) GetField4() []*NinOptNative { + return this.Field4 +} + +func (this *NinRepStruct) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepStruct) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepStruct) GetField8() []*NidOptNative { + return this.Field8 +} + +func (this *NinRepStruct) GetField13() []bool { + return this.Field13 +} + +func (this *NinRepStruct) GetField14() []string { + return this.Field14 +} + +func (this *NinRepStruct) GetField15() [][]byte { + return this.Field15 +} + +func NewNinRepStructFromFace(that NinRepStructFace) *NinRepStruct { + this := &NinRepStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidEmbeddedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() NidOptNative + GetField210() bool +} + +func (this *NidEmbeddedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidEmbeddedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidEmbeddedStructFromFace(this) +} + +func (this *NidEmbeddedStruct) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NidEmbeddedStruct) GetField200() NidOptNative { + return this.Field200 +} + +func (this *NidEmbeddedStruct) GetField210() bool { + return this.Field210 +} + +func NewNidEmbeddedStructFromFace(that NidEmbeddedStructFace) *NidEmbeddedStruct { + this := &NidEmbeddedStruct{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NinEmbeddedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() *NidOptNative + GetField210() *bool +} + +func (this *NinEmbeddedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinEmbeddedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinEmbeddedStructFromFace(this) +} + +func (this *NinEmbeddedStruct) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NinEmbeddedStruct) GetField200() *NidOptNative { + return this.Field200 +} + +func (this *NinEmbeddedStruct) GetField210() *bool { + return this.Field210 +} + +func NewNinEmbeddedStructFromFace(that NinEmbeddedStructFace) *NinEmbeddedStruct { + this := &NinEmbeddedStruct{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NidNestedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() NidOptStruct + GetField2() []NidRepStruct +} + +func (this *NidNestedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidNestedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidNestedStructFromFace(this) +} + +func (this *NidNestedStruct) GetField1() NidOptStruct { + return this.Field1 +} + +func (this *NidNestedStruct) GetField2() []NidRepStruct { + return this.Field2 +} + +func NewNidNestedStructFromFace(that NidNestedStructFace) *NidNestedStruct { + this := &NidNestedStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + return this +} + +type NinNestedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *NinOptStruct + GetField2() []*NinRepStruct +} + +func (this *NinNestedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinNestedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinNestedStructFromFace(this) +} + +func (this *NinNestedStruct) GetField1() *NinOptStruct { + return this.Field1 +} + +func (this *NinNestedStruct) GetField2() []*NinRepStruct { + return this.Field2 +} + +func NewNinNestedStructFromFace(that NinNestedStructFace) *NinNestedStruct { + this := &NinNestedStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + return this +} + +type NidOptCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() Uuid + GetValue() github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NidOptCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptCustomFromFace(this) +} + +func (this *NidOptCustom) GetId() Uuid { + return this.Id +} + +func (this *NidOptCustom) GetValue() github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNidOptCustomFromFace(that NidOptCustomFace) *NidOptCustom { + this := &NidOptCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type CustomDashFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetValue() *github_com_gogo_protobuf_test_custom_dash_type.Bytes +} + +func (this *CustomDash) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomDash) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomDashFromFace(this) +} + +func (this *CustomDash) GetValue() *github_com_gogo_protobuf_test_custom_dash_type.Bytes { + return this.Value +} + +func NewCustomDashFromFace(that CustomDashFace) *CustomDash { + this := &CustomDash{} + this.Value = that.GetValue() + return this +} + +type NinOptCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() *Uuid + GetValue() *github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NinOptCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptCustomFromFace(this) +} + +func (this *NinOptCustom) GetId() *Uuid { + return this.Id +} + +func (this *NinOptCustom) GetValue() *github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNinOptCustomFromFace(that NinOptCustomFace) *NinOptCustom { + this := &NinOptCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NidRepCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() []Uuid + GetValue() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NidRepCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepCustomFromFace(this) +} + +func (this *NidRepCustom) GetId() []Uuid { + return this.Id +} + +func (this *NidRepCustom) GetValue() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNidRepCustomFromFace(that NidRepCustomFace) *NidRepCustom { + this := &NidRepCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NinRepCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() []Uuid + GetValue() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NinRepCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepCustomFromFace(this) +} + +func (this *NinRepCustom) GetId() []Uuid { + return this.Id +} + +func (this *NinRepCustom) GetValue() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNinRepCustomFromFace(that NinRepCustomFace) *NinRepCustom { + this := &NinRepCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NinOptNativeUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *int32 + GetField4() *int64 + GetField5() *uint32 + GetField6() *uint64 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptNativeUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptNativeUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptNativeUnionFromFace(this) +} + +func (this *NinOptNativeUnion) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptNativeUnion) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptNativeUnion) GetField3() *int32 { + return this.Field3 +} + +func (this *NinOptNativeUnion) GetField4() *int64 { + return this.Field4 +} + +func (this *NinOptNativeUnion) GetField5() *uint32 { + return this.Field5 +} + +func (this *NinOptNativeUnion) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptNativeUnion) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptNativeUnion) GetField14() *string { + return this.Field14 +} + +func (this *NinOptNativeUnion) GetField15() []byte { + return this.Field15 +} + +func NewNinOptNativeUnionFromFace(that NinOptNativeUnionFace) *NinOptNativeUnion { + this := &NinOptNativeUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *NidOptNative + GetField4() *NinOptNative + GetField6() *uint64 + GetField7() *int32 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptStructUnionFromFace(this) +} + +func (this *NinOptStructUnion) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptStructUnion) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptStructUnion) GetField3() *NidOptNative { + return this.Field3 +} + +func (this *NinOptStructUnion) GetField4() *NinOptNative { + return this.Field4 +} + +func (this *NinOptStructUnion) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptStructUnion) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptStructUnion) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptStructUnion) GetField14() *string { + return this.Field14 +} + +func (this *NinOptStructUnion) GetField15() []byte { + return this.Field15 +} + +func NewNinOptStructUnionFromFace(that NinOptStructUnionFace) *NinOptStructUnion { + this := &NinOptStructUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinEmbeddedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() *NinOptNative + GetField210() *bool +} + +func (this *NinEmbeddedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinEmbeddedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinEmbeddedStructUnionFromFace(this) +} + +func (this *NinEmbeddedStructUnion) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NinEmbeddedStructUnion) GetField200() *NinOptNative { + return this.Field200 +} + +func (this *NinEmbeddedStructUnion) GetField210() *bool { + return this.Field210 +} + +func NewNinEmbeddedStructUnionFromFace(that NinEmbeddedStructUnionFace) *NinEmbeddedStructUnion { + this := &NinEmbeddedStructUnion{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NinNestedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *NinOptNativeUnion + GetField2() *NinOptStructUnion + GetField3() *NinEmbeddedStructUnion +} + +func (this *NinNestedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinNestedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinNestedStructUnionFromFace(this) +} + +func (this *NinNestedStructUnion) GetField1() *NinOptNativeUnion { + return this.Field1 +} + +func (this *NinNestedStructUnion) GetField2() *NinOptStructUnion { + return this.Field2 +} + +func (this *NinNestedStructUnion) GetField3() *NinEmbeddedStructUnion { + return this.Field3 +} + +func NewNinNestedStructUnionFromFace(that NinNestedStructUnionFace) *NinNestedStructUnion { + this := &NinNestedStructUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + return this +} + +type TreeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetOr() *OrBranch + GetAnd() *AndBranch + GetLeaf() *Leaf +} + +func (this *Tree) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Tree) TestProto() github_com_gogo_protobuf_proto.Message { + return NewTreeFromFace(this) +} + +func (this *Tree) GetOr() *OrBranch { + return this.Or +} + +func (this *Tree) GetAnd() *AndBranch { + return this.And +} + +func (this *Tree) GetLeaf() *Leaf { + return this.Leaf +} + +func NewTreeFromFace(that TreeFace) *Tree { + this := &Tree{} + this.Or = that.GetOr() + this.And = that.GetAnd() + this.Leaf = that.GetLeaf() + return this +} + +type OrBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() Tree + GetRight() Tree +} + +func (this *OrBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *OrBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewOrBranchFromFace(this) +} + +func (this *OrBranch) GetLeft() Tree { + return this.Left +} + +func (this *OrBranch) GetRight() Tree { + return this.Right +} + +func NewOrBranchFromFace(that OrBranchFace) *OrBranch { + this := &OrBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type AndBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() Tree + GetRight() Tree +} + +func (this *AndBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AndBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAndBranchFromFace(this) +} + +func (this *AndBranch) GetLeft() Tree { + return this.Left +} + +func (this *AndBranch) GetRight() Tree { + return this.Right +} + +func NewAndBranchFromFace(that AndBranchFace) *AndBranch { + this := &AndBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type LeafFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetValue() int64 + GetStrValue() string +} + +func (this *Leaf) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Leaf) TestProto() github_com_gogo_protobuf_proto.Message { + return NewLeafFromFace(this) +} + +func (this *Leaf) GetValue() int64 { + return this.Value +} + +func (this *Leaf) GetStrValue() string { + return this.StrValue +} + +func NewLeafFromFace(that LeafFace) *Leaf { + this := &Leaf{} + this.Value = that.GetValue() + this.StrValue = that.GetStrValue() + return this +} + +type DeepTreeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetDown() *ADeepBranch + GetAnd() *AndDeepBranch + GetLeaf() *DeepLeaf +} + +func (this *DeepTree) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *DeepTree) TestProto() github_com_gogo_protobuf_proto.Message { + return NewDeepTreeFromFace(this) +} + +func (this *DeepTree) GetDown() *ADeepBranch { + return this.Down +} + +func (this *DeepTree) GetAnd() *AndDeepBranch { + return this.And +} + +func (this *DeepTree) GetLeaf() *DeepLeaf { + return this.Leaf +} + +func NewDeepTreeFromFace(that DeepTreeFace) *DeepTree { + this := &DeepTree{} + this.Down = that.GetDown() + this.And = that.GetAnd() + this.Leaf = that.GetLeaf() + return this +} + +type ADeepBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetDown() DeepTree +} + +func (this *ADeepBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *ADeepBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewADeepBranchFromFace(this) +} + +func (this *ADeepBranch) GetDown() DeepTree { + return this.Down +} + +func NewADeepBranchFromFace(that ADeepBranchFace) *ADeepBranch { + this := &ADeepBranch{} + this.Down = that.GetDown() + return this +} + +type AndDeepBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() DeepTree + GetRight() DeepTree +} + +func (this *AndDeepBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AndDeepBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAndDeepBranchFromFace(this) +} + +func (this *AndDeepBranch) GetLeft() DeepTree { + return this.Left +} + +func (this *AndDeepBranch) GetRight() DeepTree { + return this.Right +} + +func NewAndDeepBranchFromFace(that AndDeepBranchFace) *AndDeepBranch { + this := &AndDeepBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type DeepLeafFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetTree() Tree +} + +func (this *DeepLeaf) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *DeepLeaf) TestProto() github_com_gogo_protobuf_proto.Message { + return NewDeepLeafFromFace(this) +} + +func (this *DeepLeaf) GetTree() Tree { + return this.Tree +} + +func NewDeepLeafFromFace(that DeepLeafFace) *DeepLeaf { + this := &DeepLeaf{} + this.Tree = that.GetTree() + return this +} + +type NilFace interface { + Proto() github_com_gogo_protobuf_proto.Message +} + +func (this *Nil) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Nil) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNilFromFace(this) +} + +func NewNilFromFace(that NilFace) *Nil { + this := &Nil{} + return this +} + +type NidOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() TheTestEnum +} + +func (this *NidOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptEnumFromFace(this) +} + +func (this *NidOptEnum) GetField1() TheTestEnum { + return this.Field1 +} + +func NewNidOptEnumFromFace(that NidOptEnumFace) *NidOptEnum { + this := &NidOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type NinOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *TheTestEnum +} + +func (this *NinOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptEnumFromFace(this) +} + +func (this *NinOptEnum) GetField1() *TheTestEnum { + return this.Field1 +} + +func NewNinOptEnumFromFace(that NinOptEnumFace) *NinOptEnum { + this := &NinOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type NidRepEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []TheTestEnum +} + +func (this *NidRepEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepEnumFromFace(this) +} + +func (this *NidRepEnum) GetField1() []TheTestEnum { + return this.Field1 +} + +func NewNidRepEnumFromFace(that NidRepEnumFace) *NidRepEnum { + this := &NidRepEnum{} + this.Field1 = that.GetField1() + return this +} + +type NinRepEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []TheTestEnum +} + +func (this *NinRepEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepEnumFromFace(this) +} + +func (this *NinRepEnum) GetField1() []TheTestEnum { + return this.Field1 +} + +func NewNinRepEnumFromFace(that NinRepEnumFace) *NinRepEnum { + this := &NinRepEnum{} + this.Field1 = that.GetField1() + return this +} + +type AnotherNinOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *AnotherTestEnum +} + +func (this *AnotherNinOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AnotherNinOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAnotherNinOptEnumFromFace(this) +} + +func (this *AnotherNinOptEnum) GetField1() *AnotherTestEnum { + return this.Field1 +} + +func NewAnotherNinOptEnumFromFace(that AnotherNinOptEnumFace) *AnotherNinOptEnum { + this := &AnotherNinOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type TimerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetTime1() int64 + GetTime2() int64 + GetData() []byte +} + +func (this *Timer) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Timer) TestProto() github_com_gogo_protobuf_proto.Message { + return NewTimerFromFace(this) +} + +func (this *Timer) GetTime1() int64 { + return this.Time1 +} + +func (this *Timer) GetTime2() int64 { + return this.Time2 +} + +func (this *Timer) GetData() []byte { + return this.Data +} + +func NewTimerFromFace(that TimerFace) *Timer { + this := &Timer{} + this.Time1 = that.GetTime1() + this.Time2 = that.GetTime2() + this.Data = that.GetData() + return this +} + +type NestedDefinitionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *int64 + GetEnumField() *NestedDefinition_NestedEnum + GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg + GetNM() *NestedDefinition_NestedMessage +} + +func (this *NestedDefinition) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinitionFromFace(this) +} + +func (this *NestedDefinition) GetField1() *int64 { + return this.Field1 +} + +func (this *NestedDefinition) GetEnumField() *NestedDefinition_NestedEnum { + return this.EnumField +} + +func (this *NestedDefinition) GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.NNM +} + +func (this *NestedDefinition) GetNM() *NestedDefinition_NestedMessage { + return this.NM +} + +func NewNestedDefinitionFromFace(that NestedDefinitionFace) *NestedDefinition { + this := &NestedDefinition{} + this.Field1 = that.GetField1() + this.EnumField = that.GetEnumField() + this.NNM = that.GetNNM() + this.NM = that.GetNM() + return this +} + +type NestedDefinition_NestedMessageFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNestedField1() *uint64 + GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg +} + +func (this *NestedDefinition_NestedMessage) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition_NestedMessage) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinition_NestedMessageFromFace(this) +} + +func (this *NestedDefinition_NestedMessage) GetNestedField1() *uint64 { + return this.NestedField1 +} + +func (this *NestedDefinition_NestedMessage) GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.NNM +} + +func NewNestedDefinition_NestedMessageFromFace(that NestedDefinition_NestedMessageFace) *NestedDefinition_NestedMessage { + this := &NestedDefinition_NestedMessage{} + this.NestedField1 = that.GetNestedField1() + this.NNM = that.GetNNM() + return this +} + +type NestedDefinition_NestedMessage_NestedNestedMsgFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNestedNestedField1() *string +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinition_NestedMessage_NestedNestedMsgFromFace(this) +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) GetNestedNestedField1() *string { + return this.NestedNestedField1 +} + +func NewNestedDefinition_NestedMessage_NestedNestedMsgFromFace(that NestedDefinition_NestedMessage_NestedNestedMsgFace) *NestedDefinition_NestedMessage_NestedNestedMsg { + this := &NestedDefinition_NestedMessage_NestedNestedMsg{} + this.NestedNestedField1 = that.GetNestedNestedField1() + return this +} + +type NestedScopeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetA() *NestedDefinition_NestedMessage_NestedNestedMsg + GetB() *NestedDefinition_NestedEnum + GetC() *NestedDefinition_NestedMessage +} + +func (this *NestedScope) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedScope) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedScopeFromFace(this) +} + +func (this *NestedScope) GetA() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.A +} + +func (this *NestedScope) GetB() *NestedDefinition_NestedEnum { + return this.B +} + +func (this *NestedScope) GetC() *NestedDefinition_NestedMessage { + return this.C +} + +func NewNestedScopeFromFace(that NestedScopeFace) *NestedScope { + this := &NestedScope{} + this.A = that.GetA() + this.B = that.GetB() + this.C = that.GetC() + return this +} + +type CustomContainerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetCustomStruct() NidOptCustom +} + +func (this *CustomContainer) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomContainer) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomContainerFromFace(this) +} + +func (this *CustomContainer) GetCustomStruct() NidOptCustom { + return this.CustomStruct +} + +func NewCustomContainerFromFace(that CustomContainerFace) *CustomContainer { + this := &CustomContainer{} + this.CustomStruct = that.GetCustomStruct() + return this +} + +type CustomNameNidOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() float64 + GetFieldB() float32 + GetFieldC() int32 + GetFieldD() int64 + GetFieldE() uint32 + GetFieldF() uint64 + GetFieldG() int32 + GetFieldH() int64 + GetFieldI() uint32 + GetFieldJ() int32 + GetFieldK() uint64 + GetFieldL() int64 + GetFieldM() bool + GetFieldN() string + GetFieldO() []byte +} + +func (this *CustomNameNidOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNidOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNidOptNativeFromFace(this) +} + +func (this *CustomNameNidOptNative) GetFieldA() float64 { + return this.FieldA +} + +func (this *CustomNameNidOptNative) GetFieldB() float32 { + return this.FieldB +} + +func (this *CustomNameNidOptNative) GetFieldC() int32 { + return this.FieldC +} + +func (this *CustomNameNidOptNative) GetFieldD() int64 { + return this.FieldD +} + +func (this *CustomNameNidOptNative) GetFieldE() uint32 { + return this.FieldE +} + +func (this *CustomNameNidOptNative) GetFieldF() uint64 { + return this.FieldF +} + +func (this *CustomNameNidOptNative) GetFieldG() int32 { + return this.FieldG +} + +func (this *CustomNameNidOptNative) GetFieldH() int64 { + return this.FieldH +} + +func (this *CustomNameNidOptNative) GetFieldI() uint32 { + return this.FieldI +} + +func (this *CustomNameNidOptNative) GetFieldJ() int32 { + return this.FieldJ +} + +func (this *CustomNameNidOptNative) GetFieldK() uint64 { + return this.FieldK +} + +func (this *CustomNameNidOptNative) GetFieldL() int64 { + return this.FieldL +} + +func (this *CustomNameNidOptNative) GetFieldM() bool { + return this.FieldM +} + +func (this *CustomNameNidOptNative) GetFieldN() string { + return this.FieldN +} + +func (this *CustomNameNidOptNative) GetFieldO() []byte { + return this.FieldO +} + +func NewCustomNameNidOptNativeFromFace(that CustomNameNidOptNativeFace) *CustomNameNidOptNative { + this := &CustomNameNidOptNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FieldL = that.GetFieldL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *float64 + GetFieldB() *float32 + GetFieldC() *int32 + GetFieldD() *int64 + GetFieldE() *uint32 + GetFieldF() *uint64 + GetFieldG() *int32 + GetFieldH() *int64 + GetFieldI() *uint32 + GetFieldJ() *int32 + GetFieldK() *uint64 + GetFielL() *int64 + GetFieldM() *bool + GetFieldN() *string + GetFieldO() []byte +} + +func (this *CustomNameNinOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinOptNativeFromFace(this) +} + +func (this *CustomNameNinOptNative) GetFieldA() *float64 { + return this.FieldA +} + +func (this *CustomNameNinOptNative) GetFieldB() *float32 { + return this.FieldB +} + +func (this *CustomNameNinOptNative) GetFieldC() *int32 { + return this.FieldC +} + +func (this *CustomNameNinOptNative) GetFieldD() *int64 { + return this.FieldD +} + +func (this *CustomNameNinOptNative) GetFieldE() *uint32 { + return this.FieldE +} + +func (this *CustomNameNinOptNative) GetFieldF() *uint64 { + return this.FieldF +} + +func (this *CustomNameNinOptNative) GetFieldG() *int32 { + return this.FieldG +} + +func (this *CustomNameNinOptNative) GetFieldH() *int64 { + return this.FieldH +} + +func (this *CustomNameNinOptNative) GetFieldI() *uint32 { + return this.FieldI +} + +func (this *CustomNameNinOptNative) GetFieldJ() *int32 { + return this.FieldJ +} + +func (this *CustomNameNinOptNative) GetFieldK() *uint64 { + return this.FieldK +} + +func (this *CustomNameNinOptNative) GetFielL() *int64 { + return this.FielL +} + +func (this *CustomNameNinOptNative) GetFieldM() *bool { + return this.FieldM +} + +func (this *CustomNameNinOptNative) GetFieldN() *string { + return this.FieldN +} + +func (this *CustomNameNinOptNative) GetFieldO() []byte { + return this.FieldO +} + +func NewCustomNameNinOptNativeFromFace(that CustomNameNinOptNativeFace) *CustomNameNinOptNative { + this := &CustomNameNinOptNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FielL = that.GetFielL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() []float64 + GetFieldB() []float32 + GetFieldC() []int32 + GetFieldD() []int64 + GetFieldE() []uint32 + GetFieldF() []uint64 + GetFieldG() []int32 + GetFieldH() []int64 + GetFieldI() []uint32 + GetFieldJ() []int32 + GetFieldK() []uint64 + GetFieldL() []int64 + GetFieldM() []bool + GetFieldN() []string + GetFieldO() [][]byte +} + +func (this *CustomNameNinRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinRepNativeFromFace(this) +} + +func (this *CustomNameNinRepNative) GetFieldA() []float64 { + return this.FieldA +} + +func (this *CustomNameNinRepNative) GetFieldB() []float32 { + return this.FieldB +} + +func (this *CustomNameNinRepNative) GetFieldC() []int32 { + return this.FieldC +} + +func (this *CustomNameNinRepNative) GetFieldD() []int64 { + return this.FieldD +} + +func (this *CustomNameNinRepNative) GetFieldE() []uint32 { + return this.FieldE +} + +func (this *CustomNameNinRepNative) GetFieldF() []uint64 { + return this.FieldF +} + +func (this *CustomNameNinRepNative) GetFieldG() []int32 { + return this.FieldG +} + +func (this *CustomNameNinRepNative) GetFieldH() []int64 { + return this.FieldH +} + +func (this *CustomNameNinRepNative) GetFieldI() []uint32 { + return this.FieldI +} + +func (this *CustomNameNinRepNative) GetFieldJ() []int32 { + return this.FieldJ +} + +func (this *CustomNameNinRepNative) GetFieldK() []uint64 { + return this.FieldK +} + +func (this *CustomNameNinRepNative) GetFieldL() []int64 { + return this.FieldL +} + +func (this *CustomNameNinRepNative) GetFieldM() []bool { + return this.FieldM +} + +func (this *CustomNameNinRepNative) GetFieldN() []string { + return this.FieldN +} + +func (this *CustomNameNinRepNative) GetFieldO() [][]byte { + return this.FieldO +} + +func NewCustomNameNinRepNativeFromFace(that CustomNameNinRepNativeFace) *CustomNameNinRepNative { + this := &CustomNameNinRepNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FieldL = that.GetFieldL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *float64 + GetFieldB() *float32 + GetFieldC() *NidOptNative + GetFieldD() []*NinOptNative + GetFieldE() *uint64 + GetFieldF() *int32 + GetFieldG() *NidOptNative + GetFieldH() *bool + GetFieldI() *string + GetFieldJ() []byte +} + +func (this *CustomNameNinStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinStructFromFace(this) +} + +func (this *CustomNameNinStruct) GetFieldA() *float64 { + return this.FieldA +} + +func (this *CustomNameNinStruct) GetFieldB() *float32 { + return this.FieldB +} + +func (this *CustomNameNinStruct) GetFieldC() *NidOptNative { + return this.FieldC +} + +func (this *CustomNameNinStruct) GetFieldD() []*NinOptNative { + return this.FieldD +} + +func (this *CustomNameNinStruct) GetFieldE() *uint64 { + return this.FieldE +} + +func (this *CustomNameNinStruct) GetFieldF() *int32 { + return this.FieldF +} + +func (this *CustomNameNinStruct) GetFieldG() *NidOptNative { + return this.FieldG +} + +func (this *CustomNameNinStruct) GetFieldH() *bool { + return this.FieldH +} + +func (this *CustomNameNinStruct) GetFieldI() *string { + return this.FieldI +} + +func (this *CustomNameNinStruct) GetFieldJ() []byte { + return this.FieldJ +} + +func NewCustomNameNinStructFromFace(that CustomNameNinStructFace) *CustomNameNinStruct { + this := &CustomNameNinStruct{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + return this +} + +type CustomNameCustomTypeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *Uuid + GetFieldB() *github_com_gogo_protobuf_test_custom.Uint128 + GetFieldC() []Uuid + GetFieldD() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *CustomNameCustomType) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameCustomType) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameCustomTypeFromFace(this) +} + +func (this *CustomNameCustomType) GetFieldA() *Uuid { + return this.FieldA +} + +func (this *CustomNameCustomType) GetFieldB() *github_com_gogo_protobuf_test_custom.Uint128 { + return this.FieldB +} + +func (this *CustomNameCustomType) GetFieldC() []Uuid { + return this.FieldC +} + +func (this *CustomNameCustomType) GetFieldD() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.FieldD +} + +func NewCustomNameCustomTypeFromFace(that CustomNameCustomTypeFace) *CustomNameCustomType { + this := &CustomNameCustomType{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + return this +} + +type CustomNameNinEmbeddedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetFieldA() *NinOptNative + GetFieldB() *bool +} + +func (this *CustomNameNinEmbeddedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinEmbeddedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinEmbeddedStructUnionFromFace(this) +} + +func (this *CustomNameNinEmbeddedStructUnion) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *CustomNameNinEmbeddedStructUnion) GetFieldA() *NinOptNative { + return this.FieldA +} + +func (this *CustomNameNinEmbeddedStructUnion) GetFieldB() *bool { + return this.FieldB +} + +func NewCustomNameNinEmbeddedStructUnionFromFace(that CustomNameNinEmbeddedStructUnionFace) *CustomNameNinEmbeddedStructUnion { + this := &CustomNameNinEmbeddedStructUnion{} + this.NidOptNative = that.GetNidOptNative() + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + return this +} + +type CustomNameEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *TheTestEnum + GetFieldB() []TheTestEnum +} + +func (this *CustomNameEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameEnumFromFace(this) +} + +func (this *CustomNameEnum) GetFieldA() *TheTestEnum { + return this.FieldA +} + +func (this *CustomNameEnum) GetFieldB() []TheTestEnum { + return this.FieldB +} + +func NewCustomNameEnumFromFace(that CustomNameEnumFace) *CustomNameEnum { + this := &CustomNameEnum{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + return this +} + +type UnrecognizedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *string +} + +func (this *Unrecognized) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Unrecognized) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedFromFace(this) +} + +func (this *Unrecognized) GetField1() *string { + return this.Field1 +} + +func NewUnrecognizedFromFace(that UnrecognizedFace) *Unrecognized { + this := &Unrecognized{} + this.Field1 = that.GetField1() + return this +} + +type UnrecognizedWithInnerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetEmbedded() []*UnrecognizedWithInner_Inner + GetField2() *string +} + +func (this *UnrecognizedWithInner) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithInner) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithInnerFromFace(this) +} + +func (this *UnrecognizedWithInner) GetEmbedded() []*UnrecognizedWithInner_Inner { + return this.Embedded +} + +func (this *UnrecognizedWithInner) GetField2() *string { + return this.Field2 +} + +func NewUnrecognizedWithInnerFromFace(that UnrecognizedWithInnerFace) *UnrecognizedWithInner { + this := &UnrecognizedWithInner{} + this.Embedded = that.GetEmbedded() + this.Field2 = that.GetField2() + return this +} + +type UnrecognizedWithInner_InnerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *uint32 +} + +func (this *UnrecognizedWithInner_Inner) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithInner_Inner) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithInner_InnerFromFace(this) +} + +func (this *UnrecognizedWithInner_Inner) GetField1() *uint32 { + return this.Field1 +} + +func NewUnrecognizedWithInner_InnerFromFace(that UnrecognizedWithInner_InnerFace) *UnrecognizedWithInner_Inner { + this := &UnrecognizedWithInner_Inner{} + this.Field1 = that.GetField1() + return this +} + +type UnrecognizedWithEmbedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetUnrecognizedWithEmbed_Embedded() UnrecognizedWithEmbed_Embedded + GetField2() *string +} + +func (this *UnrecognizedWithEmbed) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithEmbed) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithEmbedFromFace(this) +} + +func (this *UnrecognizedWithEmbed) GetUnrecognizedWithEmbed_Embedded() UnrecognizedWithEmbed_Embedded { + return this.UnrecognizedWithEmbed_Embedded +} + +func (this *UnrecognizedWithEmbed) GetField2() *string { + return this.Field2 +} + +func NewUnrecognizedWithEmbedFromFace(that UnrecognizedWithEmbedFace) *UnrecognizedWithEmbed { + this := &UnrecognizedWithEmbed{} + this.UnrecognizedWithEmbed_Embedded = that.GetUnrecognizedWithEmbed_Embedded() + this.Field2 = that.GetField2() + return this +} + +type UnrecognizedWithEmbed_EmbeddedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *uint32 +} + +func (this *UnrecognizedWithEmbed_Embedded) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithEmbed_Embedded) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithEmbed_EmbeddedFromFace(this) +} + +func (this *UnrecognizedWithEmbed_Embedded) GetField1() *uint32 { + return this.Field1 +} + +func NewUnrecognizedWithEmbed_EmbeddedFromFace(that UnrecognizedWithEmbed_EmbeddedFace) *UnrecognizedWithEmbed_Embedded { + this := &UnrecognizedWithEmbed_Embedded{} + this.Field1 = that.GetField1() + return this +} + +func (this *NidOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NidOptNative{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinOptNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+valueToGoStringThetest(this.Field8, "int64")+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+valueToGoStringThetest(this.Field9, "uint32")+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+valueToGoStringThetest(this.Field10, "int32")+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+valueToGoStringThetest(this.Field11, "uint64")+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+valueToGoStringThetest(this.Field12, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NidRepNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinRepNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepPackedNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 17) + s = append(s, "&test.NidRepPackedNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepPackedNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 17) + s = append(s, "&test.NinRepPackedNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NidOptStruct{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + s = append(s, "Field3: "+strings.Replace(this.Field3.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field4: "+strings.Replace(this.Field4.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + s = append(s, "Field8: "+strings.Replace(this.Field8.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NinOptStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NidRepStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+strings.Replace(fmt.Sprintf("%#v", this.Field3), `&`, ``, 1)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+strings.Replace(fmt.Sprintf("%#v", this.Field4), `&`, ``, 1)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+strings.Replace(fmt.Sprintf("%#v", this.Field8), `&`, ``, 1)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NinRepStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidEmbeddedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NidEmbeddedStruct{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + s = append(s, "Field200: "+strings.Replace(this.Field200.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field210: "+fmt.Sprintf("%#v", this.Field210)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinEmbeddedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinEmbeddedStruct{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.Field200 != nil { + s = append(s, "Field200: "+fmt.Sprintf("%#v", this.Field200)+",\n") + } + if this.Field210 != nil { + s = append(s, "Field210: "+valueToGoStringThetest(this.Field210, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidNestedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidNestedStruct{") + s = append(s, "Field1: "+strings.Replace(this.Field1.GoString(), `&`, ``, 1)+",\n") + if this.Field2 != nil { + s = append(s, "Field2: "+strings.Replace(fmt.Sprintf("%#v", this.Field2), `&`, ``, 1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinNestedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinNestedStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidOptCustom{") + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomDash) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.CustomDash{") + if this.Value != nil { + s = append(s, "Value: "+valueToGoStringThetest(this.Value, "github_com_gogo_protobuf_test_custom_dash_type.Bytes")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinOptCustom{") + if this.Id != nil { + s = append(s, "Id: "+valueToGoStringThetest(this.Id, "Uuid")+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+valueToGoStringThetest(this.Value, "github_com_gogo_protobuf_test_custom.Uint128")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidRepCustom{") + if this.Id != nil { + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinRepCustom{") + if this.Id != nil { + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNativeUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 13) + s = append(s, "&test.NinOptNativeUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 13) + s = append(s, "&test.NinOptStructUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinEmbeddedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinEmbeddedStructUnion{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.Field200 != nil { + s = append(s, "Field200: "+fmt.Sprintf("%#v", this.Field200)+",\n") + } + if this.Field210 != nil { + s = append(s, "Field210: "+valueToGoStringThetest(this.Field210, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinNestedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinNestedStructUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Tree) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.Tree{") + if this.Or != nil { + s = append(s, "Or: "+fmt.Sprintf("%#v", this.Or)+",\n") + } + if this.And != nil { + s = append(s, "And: "+fmt.Sprintf("%#v", this.And)+",\n") + } + if this.Leaf != nil { + s = append(s, "Leaf: "+fmt.Sprintf("%#v", this.Leaf)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OrBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.OrBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AndBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.AndBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Leaf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.Leaf{") + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + s = append(s, "StrValue: "+fmt.Sprintf("%#v", this.StrValue)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DeepTree) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.DeepTree{") + if this.Down != nil { + s = append(s, "Down: "+fmt.Sprintf("%#v", this.Down)+",\n") + } + if this.And != nil { + s = append(s, "And: "+fmt.Sprintf("%#v", this.And)+",\n") + } + if this.Leaf != nil { + s = append(s, "Leaf: "+fmt.Sprintf("%#v", this.Leaf)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *ADeepBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.ADeepBranch{") + s = append(s, "Down: "+strings.Replace(this.Down.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AndDeepBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.AndDeepBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DeepLeaf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.DeepLeaf{") + s = append(s, "Tree: "+strings.Replace(this.Tree.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Nil) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 4) + s = append(s, "&test.Nil{") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NidOptEnum{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinOptEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.TheTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NidRepEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinRepEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptEnumDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinOptEnumDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.TheTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AnotherNinOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.AnotherNinOptEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.AnotherTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AnotherNinOptEnumDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.AnotherNinOptEnumDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.AnotherTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Timer) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.Timer{") + s = append(s, "Time1: "+fmt.Sprintf("%#v", this.Time1)+",\n") + s = append(s, "Time2: "+fmt.Sprintf("%#v", this.Time2)+",\n") + s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MyExtendable) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.MyExtendable{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringThetest(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OtherExtenable) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.OtherExtenable{") + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "int64")+",\n") + } + if this.M != nil { + s = append(s, "M: "+fmt.Sprintf("%#v", this.M)+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringThetest(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&test.NestedDefinition{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.EnumField != nil { + s = append(s, "EnumField: "+valueToGoStringThetest(this.EnumField, "test.NestedDefinition_NestedEnum")+",\n") + } + if this.NNM != nil { + s = append(s, "NNM: "+fmt.Sprintf("%#v", this.NNM)+",\n") + } + if this.NM != nil { + s = append(s, "NM: "+fmt.Sprintf("%#v", this.NM)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition_NestedMessage) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NestedDefinition_NestedMessage{") + if this.NestedField1 != nil { + s = append(s, "NestedField1: "+valueToGoStringThetest(this.NestedField1, "uint64")+",\n") + } + if this.NNM != nil { + s = append(s, "NNM: "+fmt.Sprintf("%#v", this.NNM)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NestedDefinition_NestedMessage_NestedNestedMsg{") + if this.NestedNestedField1 != nil { + s = append(s, "NestedNestedField1: "+valueToGoStringThetest(this.NestedNestedField1, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedScope) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NestedScope{") + if this.A != nil { + s = append(s, "A: "+fmt.Sprintf("%#v", this.A)+",\n") + } + if this.B != nil { + s = append(s, "B: "+valueToGoStringThetest(this.B, "test.NestedDefinition_NestedEnum")+",\n") + } + if this.C != nil { + s = append(s, "C: "+fmt.Sprintf("%#v", this.C)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNativeDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinOptNativeDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+valueToGoStringThetest(this.Field8, "int64")+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+valueToGoStringThetest(this.Field9, "uint32")+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+valueToGoStringThetest(this.Field10, "int32")+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+valueToGoStringThetest(this.Field11, "uint64")+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+valueToGoStringThetest(this.Field12, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomContainer) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.CustomContainer{") + s = append(s, "CustomStruct: "+strings.Replace(this.CustomStruct.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNidOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNidOptNative{") + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + s = append(s, "FieldE: "+fmt.Sprintf("%#v", this.FieldE)+",\n") + s = append(s, "FieldF: "+fmt.Sprintf("%#v", this.FieldF)+",\n") + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + s = append(s, "FieldH: "+fmt.Sprintf("%#v", this.FieldH)+",\n") + s = append(s, "FieldI: "+fmt.Sprintf("%#v", this.FieldI)+",\n") + s = append(s, "FieldJ: "+fmt.Sprintf("%#v", this.FieldJ)+",\n") + s = append(s, "FieldK: "+fmt.Sprintf("%#v", this.FieldK)+",\n") + s = append(s, "FieldL: "+fmt.Sprintf("%#v", this.FieldL)+",\n") + s = append(s, "FieldM: "+fmt.Sprintf("%#v", this.FieldM)+",\n") + s = append(s, "FieldN: "+fmt.Sprintf("%#v", this.FieldN)+",\n") + s = append(s, "FieldO: "+fmt.Sprintf("%#v", this.FieldO)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNinOptNative{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "float64")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "float32")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+valueToGoStringThetest(this.FieldC, "int32")+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+valueToGoStringThetest(this.FieldD, "int64")+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+valueToGoStringThetest(this.FieldE, "uint32")+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+valueToGoStringThetest(this.FieldF, "uint64")+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+valueToGoStringThetest(this.FieldG, "int32")+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+valueToGoStringThetest(this.FieldH, "int64")+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+valueToGoStringThetest(this.FieldI, "uint32")+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+valueToGoStringThetest(this.FieldJ, "int32")+",\n") + } + if this.FieldK != nil { + s = append(s, "FieldK: "+valueToGoStringThetest(this.FieldK, "uint64")+",\n") + } + if this.FielL != nil { + s = append(s, "FielL: "+valueToGoStringThetest(this.FielL, "int64")+",\n") + } + if this.FieldM != nil { + s = append(s, "FieldM: "+valueToGoStringThetest(this.FieldM, "bool")+",\n") + } + if this.FieldN != nil { + s = append(s, "FieldN: "+valueToGoStringThetest(this.FieldN, "string")+",\n") + } + if this.FieldO != nil { + s = append(s, "FieldO: "+valueToGoStringThetest(this.FieldO, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNinRepNative{") + if this.FieldA != nil { + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+fmt.Sprintf("%#v", this.FieldE)+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+fmt.Sprintf("%#v", this.FieldF)+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+fmt.Sprintf("%#v", this.FieldH)+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+fmt.Sprintf("%#v", this.FieldI)+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+fmt.Sprintf("%#v", this.FieldJ)+",\n") + } + if this.FieldK != nil { + s = append(s, "FieldK: "+fmt.Sprintf("%#v", this.FieldK)+",\n") + } + if this.FieldL != nil { + s = append(s, "FieldL: "+fmt.Sprintf("%#v", this.FieldL)+",\n") + } + if this.FieldM != nil { + s = append(s, "FieldM: "+fmt.Sprintf("%#v", this.FieldM)+",\n") + } + if this.FieldN != nil { + s = append(s, "FieldN: "+fmt.Sprintf("%#v", this.FieldN)+",\n") + } + if this.FieldO != nil { + s = append(s, "FieldO: "+fmt.Sprintf("%#v", this.FieldO)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.CustomNameNinStruct{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "float64")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "float32")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+valueToGoStringThetest(this.FieldE, "uint64")+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+valueToGoStringThetest(this.FieldF, "int32")+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+valueToGoStringThetest(this.FieldH, "bool")+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+valueToGoStringThetest(this.FieldI, "string")+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+valueToGoStringThetest(this.FieldJ, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameCustomType) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&test.CustomNameCustomType{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "Uuid")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "github_com_gogo_protobuf_test_custom.Uint128")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinEmbeddedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.CustomNameNinEmbeddedStructUnion{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.FieldA != nil { + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.CustomNameEnum{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "test.TheTestEnum")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NoExtensionsMap) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NoExtensionsMap{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+fmt.Sprintf("%#v", this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Unrecognized) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.Unrecognized{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "string")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithInner) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.UnrecognizedWithInner{") + if this.Embedded != nil { + s = append(s, "Embedded: "+fmt.Sprintf("%#v", this.Embedded)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithInner_Inner) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.UnrecognizedWithInner_Inner{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "uint32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithEmbed) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.UnrecognizedWithEmbed{") + s = append(s, "UnrecognizedWithEmbed_Embedded: "+strings.Replace(this.UnrecognizedWithEmbed_Embedded.GoString(), `&`, ``, 1)+",\n") + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithEmbed_Embedded) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.UnrecognizedWithEmbed_Embedded{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "uint32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringThetest(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringThetest(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *NidOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(m.Field1))) + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(m.Field2))) + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3)) + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field4)) + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field5)) + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field6)) + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31)))) + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(m.Field8)<<1)^uint64((m.Field8>>63)))) + data[i] = 0x4d + i++ + i = encodeFixed32Thetest(data, i, uint32(m.Field9)) + data[i] = 0x55 + i++ + i = encodeFixed32Thetest(data, i, uint32(m.Field10)) + data[i] = 0x59 + i++ + i = encodeFixed64Thetest(data, i, uint64(m.Field11)) + data[i] = 0x61 + i++ + i = encodeFixed64Thetest(data, i, uint64(m.Field12)) + data[i] = 0x68 + i++ + if m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field14))) + i += copy(data[i:], m.Field14) + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(*m.Field1))) + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(*m.Field2))) + } + if m.Field3 != nil { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field3)) + } + if m.Field4 != nil { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field4)) + } + if m.Field5 != nil { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field5)) + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field8 != nil { + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(*m.Field8)<<1)^uint64((*m.Field8>>63)))) + } + if m.Field9 != nil { + data[i] = 0x4d + i++ + i = encodeFixed32Thetest(data, i, uint32(*m.Field9)) + } + if m.Field10 != nil { + data[i] = 0x55 + i++ + i = encodeFixed32Thetest(data, i, uint32(*m.Field10)) + } + if m.Field11 != nil { + data[i] = 0x59 + i++ + i = encodeFixed64Thetest(data, i, uint64(*m.Field11)) + } + if m.Field12 != nil { + data[i] = 0x61 + i++ + i = encodeFixed64Thetest(data, i, uint64(*m.Field12)) + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x9 + i++ + f1 := math.Float64bits(num) + data[i] = uint8(f1) + i++ + data[i] = uint8(f1 >> 8) + i++ + data[i] = uint8(f1 >> 16) + i++ + data[i] = uint8(f1 >> 24) + i++ + data[i] = uint8(f1 >> 32) + i++ + data[i] = uint8(f1 >> 40) + i++ + data[i] = uint8(f1 >> 48) + i++ + data[i] = uint8(f1 >> 56) + i++ + } + } + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x15 + i++ + f2 := math.Float32bits(num) + data[i] = uint8(f2) + i++ + data[i] = uint8(f2 >> 8) + i++ + data[i] = uint8(f2 >> 16) + i++ + data[i] = uint8(f2 >> 24) + i++ + } + } + if len(m.Field3) > 0 { + for _, num := range m.Field3 { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field4) > 0 { + for _, num := range m.Field4 { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field5) > 0 { + for _, num := range m.Field5 { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field6) > 0 { + for _, num := range m.Field6 { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x38 + i++ + x3 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x3 >= 1<<7 { + data[i] = uint8(uint64(x3)&0x7f | 0x80) + x3 >>= 7 + i++ + } + data[i] = uint8(x3) + i++ + } + } + if len(m.Field8) > 0 { + for _, num := range m.Field8 { + data[i] = 0x40 + i++ + x4 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x4 >= 1<<7 { + data[i] = uint8(uint64(x4)&0x7f | 0x80) + x4 >>= 7 + i++ + } + data[i] = uint8(x4) + i++ + } + } + if len(m.Field9) > 0 { + for _, num := range m.Field9 { + data[i] = 0x4d + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field10) > 0 { + for _, num := range m.Field10 { + data[i] = 0x55 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field11) > 0 { + for _, num := range m.Field11 { + data[i] = 0x59 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field12) > 0 { + for _, num := range m.Field12 { + data[i] = 0x61 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field13) > 0 { + for _, b := range m.Field13 { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x9 + i++ + f5 := math.Float64bits(num) + data[i] = uint8(f5) + i++ + data[i] = uint8(f5 >> 8) + i++ + data[i] = uint8(f5 >> 16) + i++ + data[i] = uint8(f5 >> 24) + i++ + data[i] = uint8(f5 >> 32) + i++ + data[i] = uint8(f5 >> 40) + i++ + data[i] = uint8(f5 >> 48) + i++ + data[i] = uint8(f5 >> 56) + i++ + } + } + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x15 + i++ + f6 := math.Float32bits(num) + data[i] = uint8(f6) + i++ + data[i] = uint8(f6 >> 8) + i++ + data[i] = uint8(f6 >> 16) + i++ + data[i] = uint8(f6 >> 24) + i++ + } + } + if len(m.Field3) > 0 { + for _, num := range m.Field3 { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field4) > 0 { + for _, num := range m.Field4 { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field5) > 0 { + for _, num := range m.Field5 { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field6) > 0 { + for _, num := range m.Field6 { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x38 + i++ + x7 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x7 >= 1<<7 { + data[i] = uint8(uint64(x7)&0x7f | 0x80) + x7 >>= 7 + i++ + } + data[i] = uint8(x7) + i++ + } + } + if len(m.Field8) > 0 { + for _, num := range m.Field8 { + data[i] = 0x40 + i++ + x8 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x8 >= 1<<7 { + data[i] = uint8(uint64(x8)&0x7f | 0x80) + x8 >>= 7 + i++ + } + data[i] = uint8(x8) + i++ + } + } + if len(m.Field9) > 0 { + for _, num := range m.Field9 { + data[i] = 0x4d + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field10) > 0 { + for _, num := range m.Field10 { + data[i] = 0x55 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field11) > 0 { + for _, num := range m.Field11 { + data[i] = 0x59 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field12) > 0 { + for _, num := range m.Field12 { + data[i] = 0x61 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field13) > 0 { + for _, b := range m.Field13 { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepPackedNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepPackedNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field1)*8)) + for _, num := range m.Field1 { + f9 := math.Float64bits(num) + data[i] = uint8(f9) + i++ + data[i] = uint8(f9 >> 8) + i++ + data[i] = uint8(f9 >> 16) + i++ + data[i] = uint8(f9 >> 24) + i++ + data[i] = uint8(f9 >> 32) + i++ + data[i] = uint8(f9 >> 40) + i++ + data[i] = uint8(f9 >> 48) + i++ + data[i] = uint8(f9 >> 56) + i++ + } + } + if len(m.Field2) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field2)*4)) + for _, num := range m.Field2 { + f10 := math.Float32bits(num) + data[i] = uint8(f10) + i++ + data[i] = uint8(f10 >> 8) + i++ + data[i] = uint8(f10 >> 16) + i++ + data[i] = uint8(f10 >> 24) + i++ + } + } + if len(m.Field3) > 0 { + data12 := make([]byte, len(m.Field3)*10) + var j11 int + for _, num1 := range m.Field3 { + num := uint64(num1) + for num >= 1<<7 { + data12[j11] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j11++ + } + data12[j11] = uint8(num) + j11++ + } + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(j11)) + i += copy(data[i:], data12[:j11]) + } + if len(m.Field4) > 0 { + data14 := make([]byte, len(m.Field4)*10) + var j13 int + for _, num1 := range m.Field4 { + num := uint64(num1) + for num >= 1<<7 { + data14[j13] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j13++ + } + data14[j13] = uint8(num) + j13++ + } + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(j13)) + i += copy(data[i:], data14[:j13]) + } + if len(m.Field5) > 0 { + data16 := make([]byte, len(m.Field5)*10) + var j15 int + for _, num := range m.Field5 { + for num >= 1<<7 { + data16[j15] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j15++ + } + data16[j15] = uint8(num) + j15++ + } + data[i] = 0x2a + i++ + i = encodeVarintThetest(data, i, uint64(j15)) + i += copy(data[i:], data16[:j15]) + } + if len(m.Field6) > 0 { + data18 := make([]byte, len(m.Field6)*10) + var j17 int + for _, num := range m.Field6 { + for num >= 1<<7 { + data18[j17] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j17++ + } + data18[j17] = uint8(num) + j17++ + } + data[i] = 0x32 + i++ + i = encodeVarintThetest(data, i, uint64(j17)) + i += copy(data[i:], data18[:j17]) + } + if len(m.Field7) > 0 { + data19 := make([]byte, len(m.Field7)*5) + var j20 int + for _, num := range m.Field7 { + x21 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x21 >= 1<<7 { + data19[j20] = uint8(uint64(x21)&0x7f | 0x80) + j20++ + x21 >>= 7 + } + data19[j20] = uint8(x21) + j20++ + } + data[i] = 0x3a + i++ + i = encodeVarintThetest(data, i, uint64(j20)) + i += copy(data[i:], data19[:j20]) + } + if len(m.Field8) > 0 { + var j22 int + data24 := make([]byte, len(m.Field8)*10) + for _, num := range m.Field8 { + x23 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x23 >= 1<<7 { + data24[j22] = uint8(uint64(x23)&0x7f | 0x80) + j22++ + x23 >>= 7 + } + data24[j22] = uint8(x23) + j22++ + } + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(j22)) + i += copy(data[i:], data24[:j22]) + } + if len(m.Field9) > 0 { + data[i] = 0x4a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field9)*4)) + for _, num := range m.Field9 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field10) > 0 { + data[i] = 0x52 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field10)*4)) + for _, num := range m.Field10 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field11) > 0 { + data[i] = 0x5a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field11)*8)) + for _, num := range m.Field11 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field12) > 0 { + data[i] = 0x62 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field12)*8)) + for _, num := range m.Field12 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field13) > 0 { + data[i] = 0x6a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field13))) + for _, b := range m.Field13 { + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepPackedNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepPackedNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field1)*8)) + for _, num := range m.Field1 { + f25 := math.Float64bits(num) + data[i] = uint8(f25) + i++ + data[i] = uint8(f25 >> 8) + i++ + data[i] = uint8(f25 >> 16) + i++ + data[i] = uint8(f25 >> 24) + i++ + data[i] = uint8(f25 >> 32) + i++ + data[i] = uint8(f25 >> 40) + i++ + data[i] = uint8(f25 >> 48) + i++ + data[i] = uint8(f25 >> 56) + i++ + } + } + if len(m.Field2) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field2)*4)) + for _, num := range m.Field2 { + f26 := math.Float32bits(num) + data[i] = uint8(f26) + i++ + data[i] = uint8(f26 >> 8) + i++ + data[i] = uint8(f26 >> 16) + i++ + data[i] = uint8(f26 >> 24) + i++ + } + } + if len(m.Field3) > 0 { + data28 := make([]byte, len(m.Field3)*10) + var j27 int + for _, num1 := range m.Field3 { + num := uint64(num1) + for num >= 1<<7 { + data28[j27] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j27++ + } + data28[j27] = uint8(num) + j27++ + } + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(j27)) + i += copy(data[i:], data28[:j27]) + } + if len(m.Field4) > 0 { + data30 := make([]byte, len(m.Field4)*10) + var j29 int + for _, num1 := range m.Field4 { + num := uint64(num1) + for num >= 1<<7 { + data30[j29] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j29++ + } + data30[j29] = uint8(num) + j29++ + } + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(j29)) + i += copy(data[i:], data30[:j29]) + } + if len(m.Field5) > 0 { + data32 := make([]byte, len(m.Field5)*10) + var j31 int + for _, num := range m.Field5 { + for num >= 1<<7 { + data32[j31] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j31++ + } + data32[j31] = uint8(num) + j31++ + } + data[i] = 0x2a + i++ + i = encodeVarintThetest(data, i, uint64(j31)) + i += copy(data[i:], data32[:j31]) + } + if len(m.Field6) > 0 { + data34 := make([]byte, len(m.Field6)*10) + var j33 int + for _, num := range m.Field6 { + for num >= 1<<7 { + data34[j33] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j33++ + } + data34[j33] = uint8(num) + j33++ + } + data[i] = 0x32 + i++ + i = encodeVarintThetest(data, i, uint64(j33)) + i += copy(data[i:], data34[:j33]) + } + if len(m.Field7) > 0 { + data35 := make([]byte, len(m.Field7)*5) + var j36 int + for _, num := range m.Field7 { + x37 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x37 >= 1<<7 { + data35[j36] = uint8(uint64(x37)&0x7f | 0x80) + j36++ + x37 >>= 7 + } + data35[j36] = uint8(x37) + j36++ + } + data[i] = 0x3a + i++ + i = encodeVarintThetest(data, i, uint64(j36)) + i += copy(data[i:], data35[:j36]) + } + if len(m.Field8) > 0 { + var j38 int + data40 := make([]byte, len(m.Field8)*10) + for _, num := range m.Field8 { + x39 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x39 >= 1<<7 { + data40[j38] = uint8(uint64(x39)&0x7f | 0x80) + j38++ + x39 >>= 7 + } + data40[j38] = uint8(x39) + j38++ + } + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(j38)) + i += copy(data[i:], data40[:j38]) + } + if len(m.Field9) > 0 { + data[i] = 0x4a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field9)*4)) + for _, num := range m.Field9 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field10) > 0 { + data[i] = 0x52 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field10)*4)) + for _, num := range m.Field10 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field11) > 0 { + data[i] = 0x5a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field11)*8)) + for _, num := range m.Field11 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field12) > 0 { + data[i] = 0x62 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field12)*8)) + for _, num := range m.Field12 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field13) > 0 { + data[i] = 0x6a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field13))) + for _, b := range m.Field13 { + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidOptStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidOptStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(m.Field1))) + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(m.Field2))) + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3.Size())) + n41, err := m.Field3.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n41 + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field4.Size())) + n42, err := m.Field4.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n42 + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field6)) + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31)))) + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field8.Size())) + n43, err := m.Field8.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n43 + data[i] = 0x68 + i++ + if m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field14))) + i += copy(data[i:], m.Field14) + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(*m.Field1))) + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(*m.Field2))) + } + if m.Field3 != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3.Size())) + n44, err := m.Field3.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n44 + } + if m.Field4 != nil { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field4.Size())) + n45, err := m.Field4.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n45 + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field8 != nil { + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field8.Size())) + n46, err := m.Field8.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n46 + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x9 + i++ + f47 := math.Float64bits(num) + data[i] = uint8(f47) + i++ + data[i] = uint8(f47 >> 8) + i++ + data[i] = uint8(f47 >> 16) + i++ + data[i] = uint8(f47 >> 24) + i++ + data[i] = uint8(f47 >> 32) + i++ + data[i] = uint8(f47 >> 40) + i++ + data[i] = uint8(f47 >> 48) + i++ + data[i] = uint8(f47 >> 56) + i++ + } + } + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x15 + i++ + f48 := math.Float32bits(num) + data[i] = uint8(f48) + i++ + data[i] = uint8(f48 >> 8) + i++ + data[i] = uint8(f48 >> 16) + i++ + data[i] = uint8(f48 >> 24) + i++ + } + } + if len(m.Field3) > 0 { + for _, msg := range m.Field3 { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field4) > 0 { + for _, msg := range m.Field4 { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field6) > 0 { + for _, num := range m.Field6 { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x38 + i++ + x49 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x49 >= 1<<7 { + data[i] = uint8(uint64(x49)&0x7f | 0x80) + x49 >>= 7 + i++ + } + data[i] = uint8(x49) + i++ + } + } + if len(m.Field8) > 0 { + for _, msg := range m.Field8 { + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field13) > 0 { + for _, b := range m.Field13 { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x9 + i++ + f50 := math.Float64bits(num) + data[i] = uint8(f50) + i++ + data[i] = uint8(f50 >> 8) + i++ + data[i] = uint8(f50 >> 16) + i++ + data[i] = uint8(f50 >> 24) + i++ + data[i] = uint8(f50 >> 32) + i++ + data[i] = uint8(f50 >> 40) + i++ + data[i] = uint8(f50 >> 48) + i++ + data[i] = uint8(f50 >> 56) + i++ + } + } + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x15 + i++ + f51 := math.Float32bits(num) + data[i] = uint8(f51) + i++ + data[i] = uint8(f51 >> 8) + i++ + data[i] = uint8(f51 >> 16) + i++ + data[i] = uint8(f51 >> 24) + i++ + } + } + if len(m.Field3) > 0 { + for _, msg := range m.Field3 { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field4) > 0 { + for _, msg := range m.Field4 { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field6) > 0 { + for _, num := range m.Field6 { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x38 + i++ + x52 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x52 >= 1<<7 { + data[i] = uint8(uint64(x52)&0x7f | 0x80) + x52 >>= 7 + i++ + } + data[i] = uint8(x52) + i++ + } + } + if len(m.Field8) > 0 { + for _, msg := range m.Field8 { + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field13) > 0 { + for _, b := range m.Field13 { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidEmbeddedStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidEmbeddedStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NidOptNative != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.NidOptNative.Size())) + n53, err := m.NidOptNative.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n53 + } + data[i] = 0xc2 + i++ + data[i] = 0xc + i++ + i = encodeVarintThetest(data, i, uint64(m.Field200.Size())) + n54, err := m.Field200.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n54 + data[i] = 0x90 + i++ + data[i] = 0xd + i++ + if m.Field210 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinEmbeddedStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinEmbeddedStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NidOptNative != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.NidOptNative.Size())) + n55, err := m.NidOptNative.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n55 + } + if m.Field200 != nil { + data[i] = 0xc2 + i++ + data[i] = 0xc + i++ + i = encodeVarintThetest(data, i, uint64(m.Field200.Size())) + n56, err := m.Field200.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n56 + } + if m.Field210 != nil { + data[i] = 0x90 + i++ + data[i] = 0xd + i++ + if *m.Field210 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidNestedStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidNestedStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Field1.Size())) + n57, err := m.Field1.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n57 + if len(m.Field2) > 0 { + for _, msg := range m.Field2 { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinNestedStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinNestedStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Field1.Size())) + n58, err := m.Field1.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n58 + } + if len(m.Field2) > 0 { + for _, msg := range m.Field2 { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidOptCustom) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidOptCustom) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Id.Size())) + n59, err := m.Id.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n59 + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Value.Size())) + n60, err := m.Value.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n60 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomDash) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomDash) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Value != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Value.Size())) + n61, err := m.Value.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n61 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptCustom) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptCustom) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Id != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Id.Size())) + n62, err := m.Id.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n62 + } + if m.Value != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Value.Size())) + n63, err := m.Value.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n63 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepCustom) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepCustom) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Id) > 0 { + for _, msg := range m.Id { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Value) > 0 { + for _, msg := range m.Value { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepCustom) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepCustom) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Id) > 0 { + for _, msg := range m.Id { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Value) > 0 { + for _, msg := range m.Value { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptNativeUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptNativeUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(*m.Field1))) + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(*m.Field2))) + } + if m.Field3 != nil { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field3)) + } + if m.Field4 != nil { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field4)) + } + if m.Field5 != nil { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field5)) + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptStructUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptStructUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(*m.Field1))) + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(*m.Field2))) + } + if m.Field3 != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3.Size())) + n64, err := m.Field3.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n64 + } + if m.Field4 != nil { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field4.Size())) + n65, err := m.Field4.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n65 + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinEmbeddedStructUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinEmbeddedStructUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NidOptNative != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.NidOptNative.Size())) + n66, err := m.NidOptNative.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n66 + } + if m.Field200 != nil { + data[i] = 0xc2 + i++ + data[i] = 0xc + i++ + i = encodeVarintThetest(data, i, uint64(m.Field200.Size())) + n67, err := m.Field200.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n67 + } + if m.Field210 != nil { + data[i] = 0x90 + i++ + data[i] = 0xd + i++ + if *m.Field210 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinNestedStructUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinNestedStructUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Field1.Size())) + n68, err := m.Field1.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n68 + } + if m.Field2 != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field2.Size())) + n69, err := m.Field2.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n69 + } + if m.Field3 != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3.Size())) + n70, err := m.Field3.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n70 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Tree) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Tree) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Or != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Or.Size())) + n71, err := m.Or.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n71 + } + if m.And != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.And.Size())) + n72, err := m.And.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n72 + } + if m.Leaf != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Leaf.Size())) + n73, err := m.Leaf.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n73 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *OrBranch) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *OrBranch) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Left.Size())) + n74, err := m.Left.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n74 + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Right.Size())) + n75, err := m.Right.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n75 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AndBranch) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AndBranch) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Left.Size())) + n76, err := m.Left.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n76 + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Right.Size())) + n77, err := m.Right.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n77 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Leaf) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Leaf) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(m.Value)) + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.StrValue))) + i += copy(data[i:], m.StrValue) + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *DeepTree) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *DeepTree) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Down != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Down.Size())) + n78, err := m.Down.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n78 + } + if m.And != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.And.Size())) + n79, err := m.And.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n79 + } + if m.Leaf != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Leaf.Size())) + n80, err := m.Leaf.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n80 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *ADeepBranch) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *ADeepBranch) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Down.Size())) + n81, err := m.Down.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n81 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AndDeepBranch) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AndDeepBranch) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Left.Size())) + n82, err := m.Left.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n82 + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Right.Size())) + n83, err := m.Right.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n83 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *DeepLeaf) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *DeepLeaf) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Tree.Size())) + n84, err := m.Tree.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n84 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Nil) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Nil) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidOptEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidOptEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field1)) + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptEnumDefault) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptEnumDefault) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AnotherNinOptEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AnotherNinOptEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AnotherNinOptEnumDefault) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AnotherNinOptEnumDefault) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Timer) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Timer) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(m.Time1)) + data[i] = 0x11 + i++ + i = encodeFixed64Thetest(data, i, uint64(m.Time2)) + if m.Data != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Data))) + i += copy(data[i:], m.Data) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *MyExtendable) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *MyExtendable) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if len(m.XXX_extensions) > 0 { + n, err := github_com_gogo_protobuf_proto.EncodeExtensionMap(m.XXX_extensions, data[i:]) + if err != nil { + return 0, err + } + i += n + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *OtherExtenable) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *OtherExtenable) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.M != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.M.Size())) + n85, err := m.M.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n85 + } + if m.Field2 != nil { + data[i] = 0x10 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field2)) + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field13)) + } + if len(m.XXX_extensions) > 0 { + n, err := github_com_gogo_protobuf_proto.EncodeExtensionMap(m.XXX_extensions, data[i:]) + if err != nil { + return 0, err + } + i += n + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NestedDefinition) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NestedDefinition) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.EnumField != nil { + data[i] = 0x10 + i++ + i = encodeVarintThetest(data, i, uint64(*m.EnumField)) + } + if m.NNM != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.NNM.Size())) + n86, err := m.NNM.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n86 + } + if m.NM != nil { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(m.NM.Size())) + n87, err := m.NM.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n87 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NestedDefinition_NestedMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NestedDefinition_NestedMessage) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NestedField1 != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(*m.NestedField1)) + } + if m.NNM != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.NNM.Size())) + n88, err := m.NNM.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n88 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NestedNestedField1 != nil { + data[i] = 0x52 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.NestedNestedField1))) + i += copy(data[i:], *m.NestedNestedField1) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NestedScope) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NestedScope) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.A != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.A.Size())) + n89, err := m.A.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n89 + } + if m.B != nil { + data[i] = 0x10 + i++ + i = encodeVarintThetest(data, i, uint64(*m.B)) + } + if m.C != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.C.Size())) + n90, err := m.C.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n90 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptNativeDefault) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptNativeDefault) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(*m.Field1))) + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(*m.Field2))) + } + if m.Field3 != nil { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field3)) + } + if m.Field4 != nil { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field4)) + } + if m.Field5 != nil { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field5)) + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field8 != nil { + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(*m.Field8)<<1)^uint64((*m.Field8>>63)))) + } + if m.Field9 != nil { + data[i] = 0x4d + i++ + i = encodeFixed32Thetest(data, i, uint32(*m.Field9)) + } + if m.Field10 != nil { + data[i] = 0x55 + i++ + i = encodeFixed32Thetest(data, i, uint32(*m.Field10)) + } + if m.Field11 != nil { + data[i] = 0x59 + i++ + i = encodeFixed64Thetest(data, i, uint64(*m.Field11)) + } + if m.Field12 != nil { + data[i] = 0x61 + i++ + i = encodeFixed64Thetest(data, i, uint64(*m.Field12)) + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomContainer) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomContainer) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.CustomStruct.Size())) + n91, err := m.CustomStruct.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n91 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNidOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNidOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(m.FieldA))) + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(m.FieldB))) + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldC)) + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldD)) + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldE)) + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldF)) + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(m.FieldG)<<1)^uint32((m.FieldG>>31)))) + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(m.FieldH)<<1)^uint64((m.FieldH>>63)))) + data[i] = 0x4d + i++ + i = encodeFixed32Thetest(data, i, uint32(m.FieldI)) + data[i] = 0x55 + i++ + i = encodeFixed32Thetest(data, i, uint32(m.FieldJ)) + data[i] = 0x59 + i++ + i = encodeFixed64Thetest(data, i, uint64(m.FieldK)) + data[i] = 0x61 + i++ + i = encodeFixed64Thetest(data, i, uint64(m.FieldL)) + data[i] = 0x68 + i++ + if m.FieldM { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.FieldN))) + i += copy(data[i:], m.FieldN) + if m.FieldO != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.FieldO))) + i += copy(data[i:], m.FieldO) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNinOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNinOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.FieldA != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(*m.FieldA))) + } + if m.FieldB != nil { + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(*m.FieldB))) + } + if m.FieldC != nil { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldC)) + } + if m.FieldD != nil { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldD)) + } + if m.FieldE != nil { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldE)) + } + if m.FieldF != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldF)) + } + if m.FieldG != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.FieldG)<<1)^uint32((*m.FieldG>>31)))) + } + if m.FieldH != nil { + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(*m.FieldH)<<1)^uint64((*m.FieldH>>63)))) + } + if m.FieldI != nil { + data[i] = 0x4d + i++ + i = encodeFixed32Thetest(data, i, uint32(*m.FieldI)) + } + if m.FieldJ != nil { + data[i] = 0x55 + i++ + i = encodeFixed32Thetest(data, i, uint32(*m.FieldJ)) + } + if m.FieldK != nil { + data[i] = 0x59 + i++ + i = encodeFixed64Thetest(data, i, uint64(*m.FieldK)) + } + if m.FielL != nil { + data[i] = 0x61 + i++ + i = encodeFixed64Thetest(data, i, uint64(*m.FielL)) + } + if m.FieldM != nil { + data[i] = 0x68 + i++ + if *m.FieldM { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.FieldN != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.FieldN))) + i += copy(data[i:], *m.FieldN) + } + if m.FieldO != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.FieldO))) + i += copy(data[i:], m.FieldO) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNinRepNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNinRepNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.FieldA) > 0 { + for _, num := range m.FieldA { + data[i] = 0x9 + i++ + f92 := math.Float64bits(num) + data[i] = uint8(f92) + i++ + data[i] = uint8(f92 >> 8) + i++ + data[i] = uint8(f92 >> 16) + i++ + data[i] = uint8(f92 >> 24) + i++ + data[i] = uint8(f92 >> 32) + i++ + data[i] = uint8(f92 >> 40) + i++ + data[i] = uint8(f92 >> 48) + i++ + data[i] = uint8(f92 >> 56) + i++ + } + } + if len(m.FieldB) > 0 { + for _, num := range m.FieldB { + data[i] = 0x15 + i++ + f93 := math.Float32bits(num) + data[i] = uint8(f93) + i++ + data[i] = uint8(f93 >> 8) + i++ + data[i] = uint8(f93 >> 16) + i++ + data[i] = uint8(f93 >> 24) + i++ + } + } + if len(m.FieldC) > 0 { + for _, num := range m.FieldC { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.FieldD) > 0 { + for _, num := range m.FieldD { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.FieldE) > 0 { + for _, num := range m.FieldE { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.FieldF) > 0 { + for _, num := range m.FieldF { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.FieldG) > 0 { + for _, num := range m.FieldG { + data[i] = 0x38 + i++ + x94 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x94 >= 1<<7 { + data[i] = uint8(uint64(x94)&0x7f | 0x80) + x94 >>= 7 + i++ + } + data[i] = uint8(x94) + i++ + } + } + if len(m.FieldH) > 0 { + for _, num := range m.FieldH { + data[i] = 0x40 + i++ + x95 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x95 >= 1<<7 { + data[i] = uint8(uint64(x95)&0x7f | 0x80) + x95 >>= 7 + i++ + } + data[i] = uint8(x95) + i++ + } + } + if len(m.FieldI) > 0 { + for _, num := range m.FieldI { + data[i] = 0x4d + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.FieldJ) > 0 { + for _, num := range m.FieldJ { + data[i] = 0x55 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.FieldK) > 0 { + for _, num := range m.FieldK { + data[i] = 0x59 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.FieldL) > 0 { + for _, num := range m.FieldL { + data[i] = 0x61 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.FieldM) > 0 { + for _, b := range m.FieldM { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.FieldN) > 0 { + for _, s := range m.FieldN { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.FieldO) > 0 { + for _, b := range m.FieldO { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNinStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNinStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.FieldA != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(*m.FieldA))) + } + if m.FieldB != nil { + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(*m.FieldB))) + } + if m.FieldC != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldC.Size())) + n96, err := m.FieldC.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n96 + } + if len(m.FieldD) > 0 { + for _, msg := range m.FieldD { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.FieldE != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldE)) + } + if m.FieldF != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.FieldF)<<1)^uint32((*m.FieldF>>31)))) + } + if m.FieldG != nil { + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldG.Size())) + n97, err := m.FieldG.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n97 + } + if m.FieldH != nil { + data[i] = 0x68 + i++ + if *m.FieldH { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.FieldI != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.FieldI))) + i += copy(data[i:], *m.FieldI) + } + if m.FieldJ != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.FieldJ))) + i += copy(data[i:], m.FieldJ) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameCustomType) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameCustomType) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.FieldA != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldA.Size())) + n98, err := m.FieldA.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n98 + } + if m.FieldB != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldB.Size())) + n99, err := m.FieldB.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n99 + } + if len(m.FieldC) > 0 { + for _, msg := range m.FieldC { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.FieldD) > 0 { + for _, msg := range m.FieldD { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNinEmbeddedStructUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNinEmbeddedStructUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NidOptNative != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.NidOptNative.Size())) + n100, err := m.NidOptNative.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n100 + } + if m.FieldA != nil { + data[i] = 0xc2 + i++ + data[i] = 0xc + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldA.Size())) + n101, err := m.FieldA.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n101 + } + if m.FieldB != nil { + data[i] = 0x90 + i++ + data[i] = 0xd + i++ + if *m.FieldB { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.FieldA != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldA)) + } + if len(m.FieldB) > 0 { + for _, num := range m.FieldB { + data[i] = 0x10 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NoExtensionsMap) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NoExtensionsMap) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + i += copy(data[i:], m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Unrecognized) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Unrecognized) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field1))) + i += copy(data[i:], *m.Field1) + } + return i, nil +} + +func (m *UnrecognizedWithInner) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnrecognizedWithInner) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Embedded) > 0 { + for _, msg := range m.Embedded { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.Field2 != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field2))) + i += copy(data[i:], *m.Field2) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *UnrecognizedWithInner_Inner) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnrecognizedWithInner_Inner) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + return i, nil +} + +func (m *UnrecognizedWithEmbed) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnrecognizedWithEmbed) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.UnrecognizedWithEmbed_Embedded.Size())) + n102, err := m.UnrecognizedWithEmbed_Embedded.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n102 + if m.Field2 != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field2))) + i += copy(data[i:], *m.Field2) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *UnrecognizedWithEmbed_Embedded) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnrecognizedWithEmbed_Embedded) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + return i, nil +} + +func encodeFixed64Thetest(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Thetest(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintThetest(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedNidOptNative(r randyThetest, easy bool) *NidOptNative { + this := &NidOptNative{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + this.Field5 = uint32(r.Uint32()) + this.Field6 = uint64(uint64(r.Uint32())) + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + this.Field9 = uint32(r.Uint32()) + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + this.Field11 = uint64(uint64(r.Uint32())) + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + this.Field13 = bool(bool(r.Intn(2) == 0)) + this.Field14 = randStringThetest(r) + v1 := r.Intn(100) + this.Field15 = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinOptNative(r randyThetest, easy bool) *NinOptNative { + this := &NinOptNative{} + if r.Intn(10) != 0 { + v2 := float64(r.Float64()) + if r.Intn(2) == 0 { + v2 *= -1 + } + this.Field1 = &v2 + } + if r.Intn(10) != 0 { + v3 := float32(r.Float32()) + if r.Intn(2) == 0 { + v3 *= -1 + } + this.Field2 = &v3 + } + if r.Intn(10) != 0 { + v4 := int32(r.Int31()) + if r.Intn(2) == 0 { + v4 *= -1 + } + this.Field3 = &v4 + } + if r.Intn(10) != 0 { + v5 := int64(r.Int63()) + if r.Intn(2) == 0 { + v5 *= -1 + } + this.Field4 = &v5 + } + if r.Intn(10) != 0 { + v6 := uint32(r.Uint32()) + this.Field5 = &v6 + } + if r.Intn(10) != 0 { + v7 := uint64(uint64(r.Uint32())) + this.Field6 = &v7 + } + if r.Intn(10) != 0 { + v8 := int32(r.Int31()) + if r.Intn(2) == 0 { + v8 *= -1 + } + this.Field7 = &v8 + } + if r.Intn(10) != 0 { + v9 := int64(r.Int63()) + if r.Intn(2) == 0 { + v9 *= -1 + } + this.Field8 = &v9 + } + if r.Intn(10) != 0 { + v10 := uint32(r.Uint32()) + this.Field9 = &v10 + } + if r.Intn(10) != 0 { + v11 := int32(r.Int31()) + if r.Intn(2) == 0 { + v11 *= -1 + } + this.Field10 = &v11 + } + if r.Intn(10) != 0 { + v12 := uint64(uint64(r.Uint32())) + this.Field11 = &v12 + } + if r.Intn(10) != 0 { + v13 := int64(r.Int63()) + if r.Intn(2) == 0 { + v13 *= -1 + } + this.Field12 = &v13 + } + if r.Intn(10) != 0 { + v14 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v14 + } + if r.Intn(10) != 0 { + v15 := randStringThetest(r) + this.Field14 = &v15 + } + if r.Intn(10) != 0 { + v16 := r.Intn(100) + this.Field15 = make([]byte, v16) + for i := 0; i < v16; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepNative(r randyThetest, easy bool) *NidRepNative { + this := &NidRepNative{} + if r.Intn(10) != 0 { + v17 := r.Intn(100) + this.Field1 = make([]float64, v17) + for i := 0; i < v17; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v18 := r.Intn(100) + this.Field2 = make([]float32, v18) + for i := 0; i < v18; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v19 := r.Intn(100) + this.Field3 = make([]int32, v19) + for i := 0; i < v19; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v20 := r.Intn(100) + this.Field4 = make([]int64, v20) + for i := 0; i < v20; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v21 := r.Intn(100) + this.Field5 = make([]uint32, v21) + for i := 0; i < v21; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v22 := r.Intn(100) + this.Field6 = make([]uint64, v22) + for i := 0; i < v22; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v23 := r.Intn(100) + this.Field7 = make([]int32, v23) + for i := 0; i < v23; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v24 := r.Intn(100) + this.Field8 = make([]int64, v24) + for i := 0; i < v24; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v25 := r.Intn(100) + this.Field9 = make([]uint32, v25) + for i := 0; i < v25; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v26 := r.Intn(100) + this.Field10 = make([]int32, v26) + for i := 0; i < v26; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v27 := r.Intn(100) + this.Field11 = make([]uint64, v27) + for i := 0; i < v27; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v28 := r.Intn(100) + this.Field12 = make([]int64, v28) + for i := 0; i < v28; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(100) + this.Field13 = make([]bool, v29) + for i := 0; i < v29; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v30 := r.Intn(10) + this.Field14 = make([]string, v30) + for i := 0; i < v30; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v31 := r.Intn(100) + this.Field15 = make([][]byte, v31) + for i := 0; i < v31; i++ { + v32 := r.Intn(100) + this.Field15[i] = make([]byte, v32) + for j := 0; j < v32; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinRepNative(r randyThetest, easy bool) *NinRepNative { + this := &NinRepNative{} + if r.Intn(10) != 0 { + v33 := r.Intn(100) + this.Field1 = make([]float64, v33) + for i := 0; i < v33; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v34 := r.Intn(100) + this.Field2 = make([]float32, v34) + for i := 0; i < v34; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v35 := r.Intn(100) + this.Field3 = make([]int32, v35) + for i := 0; i < v35; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v36 := r.Intn(100) + this.Field4 = make([]int64, v36) + for i := 0; i < v36; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v37 := r.Intn(100) + this.Field5 = make([]uint32, v37) + for i := 0; i < v37; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v38 := r.Intn(100) + this.Field6 = make([]uint64, v38) + for i := 0; i < v38; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v39 := r.Intn(100) + this.Field7 = make([]int32, v39) + for i := 0; i < v39; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v40 := r.Intn(100) + this.Field8 = make([]int64, v40) + for i := 0; i < v40; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v41 := r.Intn(100) + this.Field9 = make([]uint32, v41) + for i := 0; i < v41; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v42 := r.Intn(100) + this.Field10 = make([]int32, v42) + for i := 0; i < v42; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v43 := r.Intn(100) + this.Field11 = make([]uint64, v43) + for i := 0; i < v43; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v44 := r.Intn(100) + this.Field12 = make([]int64, v44) + for i := 0; i < v44; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v45 := r.Intn(100) + this.Field13 = make([]bool, v45) + for i := 0; i < v45; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v46 := r.Intn(10) + this.Field14 = make([]string, v46) + for i := 0; i < v46; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v47 := r.Intn(100) + this.Field15 = make([][]byte, v47) + for i := 0; i < v47; i++ { + v48 := r.Intn(100) + this.Field15[i] = make([]byte, v48) + for j := 0; j < v48; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepPackedNative(r randyThetest, easy bool) *NidRepPackedNative { + this := &NidRepPackedNative{} + if r.Intn(10) != 0 { + v49 := r.Intn(100) + this.Field1 = make([]float64, v49) + for i := 0; i < v49; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v50 := r.Intn(100) + this.Field2 = make([]float32, v50) + for i := 0; i < v50; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v51 := r.Intn(100) + this.Field3 = make([]int32, v51) + for i := 0; i < v51; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v52 := r.Intn(100) + this.Field4 = make([]int64, v52) + for i := 0; i < v52; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v53 := r.Intn(100) + this.Field5 = make([]uint32, v53) + for i := 0; i < v53; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v54 := r.Intn(100) + this.Field6 = make([]uint64, v54) + for i := 0; i < v54; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v55 := r.Intn(100) + this.Field7 = make([]int32, v55) + for i := 0; i < v55; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v56 := r.Intn(100) + this.Field8 = make([]int64, v56) + for i := 0; i < v56; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v57 := r.Intn(100) + this.Field9 = make([]uint32, v57) + for i := 0; i < v57; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v58 := r.Intn(100) + this.Field10 = make([]int32, v58) + for i := 0; i < v58; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v59 := r.Intn(100) + this.Field11 = make([]uint64, v59) + for i := 0; i < v59; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v60 := r.Intn(100) + this.Field12 = make([]int64, v60) + for i := 0; i < v60; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v61 := r.Intn(100) + this.Field13 = make([]bool, v61) + for i := 0; i < v61; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 14) + } + return this +} + +func NewPopulatedNinRepPackedNative(r randyThetest, easy bool) *NinRepPackedNative { + this := &NinRepPackedNative{} + if r.Intn(10) != 0 { + v62 := r.Intn(100) + this.Field1 = make([]float64, v62) + for i := 0; i < v62; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v63 := r.Intn(100) + this.Field2 = make([]float32, v63) + for i := 0; i < v63; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v64 := r.Intn(100) + this.Field3 = make([]int32, v64) + for i := 0; i < v64; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v65 := r.Intn(100) + this.Field4 = make([]int64, v65) + for i := 0; i < v65; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v66 := r.Intn(100) + this.Field5 = make([]uint32, v66) + for i := 0; i < v66; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v67 := r.Intn(100) + this.Field6 = make([]uint64, v67) + for i := 0; i < v67; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v68 := r.Intn(100) + this.Field7 = make([]int32, v68) + for i := 0; i < v68; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v69 := r.Intn(100) + this.Field8 = make([]int64, v69) + for i := 0; i < v69; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v70 := r.Intn(100) + this.Field9 = make([]uint32, v70) + for i := 0; i < v70; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v71 := r.Intn(100) + this.Field10 = make([]int32, v71) + for i := 0; i < v71; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v72 := r.Intn(100) + this.Field11 = make([]uint64, v72) + for i := 0; i < v72; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v73 := r.Intn(100) + this.Field12 = make([]int64, v73) + for i := 0; i < v73; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v74 := r.Intn(100) + this.Field13 = make([]bool, v74) + for i := 0; i < v74; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 14) + } + return this +} + +func NewPopulatedNidOptStruct(r randyThetest, easy bool) *NidOptStruct { + this := &NidOptStruct{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + v75 := NewPopulatedNidOptNative(r, easy) + this.Field3 = *v75 + v76 := NewPopulatedNinOptNative(r, easy) + this.Field4 = *v76 + this.Field6 = uint64(uint64(r.Uint32())) + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + v77 := NewPopulatedNidOptNative(r, easy) + this.Field8 = *v77 + this.Field13 = bool(bool(r.Intn(2) == 0)) + this.Field14 = randStringThetest(r) + v78 := r.Intn(100) + this.Field15 = make([]byte, v78) + for i := 0; i < v78; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinOptStruct(r randyThetest, easy bool) *NinOptStruct { + this := &NinOptStruct{} + if r.Intn(10) != 0 { + v79 := float64(r.Float64()) + if r.Intn(2) == 0 { + v79 *= -1 + } + this.Field1 = &v79 + } + if r.Intn(10) != 0 { + v80 := float32(r.Float32()) + if r.Intn(2) == 0 { + v80 *= -1 + } + this.Field2 = &v80 + } + if r.Intn(10) != 0 { + this.Field3 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + this.Field4 = NewPopulatedNinOptNative(r, easy) + } + if r.Intn(10) != 0 { + v81 := uint64(uint64(r.Uint32())) + this.Field6 = &v81 + } + if r.Intn(10) != 0 { + v82 := int32(r.Int31()) + if r.Intn(2) == 0 { + v82 *= -1 + } + this.Field7 = &v82 + } + if r.Intn(10) != 0 { + this.Field8 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v83 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v83 + } + if r.Intn(10) != 0 { + v84 := randStringThetest(r) + this.Field14 = &v84 + } + if r.Intn(10) != 0 { + v85 := r.Intn(100) + this.Field15 = make([]byte, v85) + for i := 0; i < v85; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepStruct(r randyThetest, easy bool) *NidRepStruct { + this := &NidRepStruct{} + if r.Intn(10) != 0 { + v86 := r.Intn(100) + this.Field1 = make([]float64, v86) + for i := 0; i < v86; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v87 := r.Intn(100) + this.Field2 = make([]float32, v87) + for i := 0; i < v87; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v88 := r.Intn(10) + this.Field3 = make([]NidOptNative, v88) + for i := 0; i < v88; i++ { + v89 := NewPopulatedNidOptNative(r, easy) + this.Field3[i] = *v89 + } + } + if r.Intn(10) != 0 { + v90 := r.Intn(10) + this.Field4 = make([]NinOptNative, v90) + for i := 0; i < v90; i++ { + v91 := NewPopulatedNinOptNative(r, easy) + this.Field4[i] = *v91 + } + } + if r.Intn(10) != 0 { + v92 := r.Intn(100) + this.Field6 = make([]uint64, v92) + for i := 0; i < v92; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v93 := r.Intn(100) + this.Field7 = make([]int32, v93) + for i := 0; i < v93; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v94 := r.Intn(10) + this.Field8 = make([]NidOptNative, v94) + for i := 0; i < v94; i++ { + v95 := NewPopulatedNidOptNative(r, easy) + this.Field8[i] = *v95 + } + } + if r.Intn(10) != 0 { + v96 := r.Intn(100) + this.Field13 = make([]bool, v96) + for i := 0; i < v96; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v97 := r.Intn(10) + this.Field14 = make([]string, v97) + for i := 0; i < v97; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v98 := r.Intn(100) + this.Field15 = make([][]byte, v98) + for i := 0; i < v98; i++ { + v99 := r.Intn(100) + this.Field15[i] = make([]byte, v99) + for j := 0; j < v99; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinRepStruct(r randyThetest, easy bool) *NinRepStruct { + this := &NinRepStruct{} + if r.Intn(10) != 0 { + v100 := r.Intn(100) + this.Field1 = make([]float64, v100) + for i := 0; i < v100; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v101 := r.Intn(100) + this.Field2 = make([]float32, v101) + for i := 0; i < v101; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v102 := r.Intn(10) + this.Field3 = make([]*NidOptNative, v102) + for i := 0; i < v102; i++ { + this.Field3[i] = NewPopulatedNidOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v103 := r.Intn(10) + this.Field4 = make([]*NinOptNative, v103) + for i := 0; i < v103; i++ { + this.Field4[i] = NewPopulatedNinOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v104 := r.Intn(100) + this.Field6 = make([]uint64, v104) + for i := 0; i < v104; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v105 := r.Intn(100) + this.Field7 = make([]int32, v105) + for i := 0; i < v105; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v106 := r.Intn(10) + this.Field8 = make([]*NidOptNative, v106) + for i := 0; i < v106; i++ { + this.Field8[i] = NewPopulatedNidOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v107 := r.Intn(100) + this.Field13 = make([]bool, v107) + for i := 0; i < v107; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v108 := r.Intn(10) + this.Field14 = make([]string, v108) + for i := 0; i < v108; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v109 := r.Intn(100) + this.Field15 = make([][]byte, v109) + for i := 0; i < v109; i++ { + v110 := r.Intn(100) + this.Field15[i] = make([]byte, v110) + for j := 0; j < v110; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidEmbeddedStruct(r randyThetest, easy bool) *NidEmbeddedStruct { + this := &NidEmbeddedStruct{} + if r.Intn(10) != 0 { + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + } + v111 := NewPopulatedNidOptNative(r, easy) + this.Field200 = *v111 + this.Field210 = bool(bool(r.Intn(2) == 0)) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 211) + } + return this +} + +func NewPopulatedNinEmbeddedStruct(r randyThetest, easy bool) *NinEmbeddedStruct { + this := &NinEmbeddedStruct{} + if r.Intn(10) != 0 { + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + this.Field200 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v112 := bool(bool(r.Intn(2) == 0)) + this.Field210 = &v112 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 211) + } + return this +} + +func NewPopulatedNidNestedStruct(r randyThetest, easy bool) *NidNestedStruct { + this := &NidNestedStruct{} + v113 := NewPopulatedNidOptStruct(r, easy) + this.Field1 = *v113 + if r.Intn(10) != 0 { + v114 := r.Intn(10) + this.Field2 = make([]NidRepStruct, v114) + for i := 0; i < v114; i++ { + v115 := NewPopulatedNidRepStruct(r, easy) + this.Field2[i] = *v115 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinNestedStruct(r randyThetest, easy bool) *NinNestedStruct { + this := &NinNestedStruct{} + if r.Intn(10) != 0 { + this.Field1 = NewPopulatedNinOptStruct(r, easy) + } + if r.Intn(10) != 0 { + v116 := r.Intn(10) + this.Field2 = make([]*NinRepStruct, v116) + for i := 0; i < v116; i++ { + this.Field2[i] = NewPopulatedNinRepStruct(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNidOptCustom(r randyThetest, easy bool) *NidOptCustom { + this := &NidOptCustom{} + v117 := NewPopulatedUuid(r) + this.Id = *v117 + v118 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value = *v118 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedCustomDash(r randyThetest, easy bool) *CustomDash { + this := &CustomDash{} + if r.Intn(10) != 0 { + this.Value = github_com_gogo_protobuf_test_custom_dash_type.NewPopulatedBytes(r) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptCustom(r randyThetest, easy bool) *NinOptCustom { + this := &NinOptCustom{} + if r.Intn(10) != 0 { + this.Id = NewPopulatedUuid(r) + } + if r.Intn(10) != 0 { + this.Value = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNidRepCustom(r randyThetest, easy bool) *NidRepCustom { + this := &NidRepCustom{} + if r.Intn(10) != 0 { + v119 := r.Intn(10) + this.Id = make([]Uuid, v119) + for i := 0; i < v119; i++ { + v120 := NewPopulatedUuid(r) + this.Id[i] = *v120 + } + } + if r.Intn(10) != 0 { + v121 := r.Intn(10) + this.Value = make([]github_com_gogo_protobuf_test_custom.Uint128, v121) + for i := 0; i < v121; i++ { + v122 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value[i] = *v122 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinRepCustom(r randyThetest, easy bool) *NinRepCustom { + this := &NinRepCustom{} + if r.Intn(10) != 0 { + v123 := r.Intn(10) + this.Id = make([]Uuid, v123) + for i := 0; i < v123; i++ { + v124 := NewPopulatedUuid(r) + this.Id[i] = *v124 + } + } + if r.Intn(10) != 0 { + v125 := r.Intn(10) + this.Value = make([]github_com_gogo_protobuf_test_custom.Uint128, v125) + for i := 0; i < v125; i++ { + v126 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value[i] = *v126 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinOptNativeUnion(r randyThetest, easy bool) *NinOptNativeUnion { + this := &NinOptNativeUnion{} + fieldNum := r.Intn(9) + switch fieldNum { + case 0: + v127 := float64(r.Float64()) + if r.Intn(2) == 0 { + v127 *= -1 + } + this.Field1 = &v127 + case 1: + v128 := float32(r.Float32()) + if r.Intn(2) == 0 { + v128 *= -1 + } + this.Field2 = &v128 + case 2: + v129 := int32(r.Int31()) + if r.Intn(2) == 0 { + v129 *= -1 + } + this.Field3 = &v129 + case 3: + v130 := int64(r.Int63()) + if r.Intn(2) == 0 { + v130 *= -1 + } + this.Field4 = &v130 + case 4: + v131 := uint32(r.Uint32()) + this.Field5 = &v131 + case 5: + v132 := uint64(uint64(r.Uint32())) + this.Field6 = &v132 + case 6: + v133 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v133 + case 7: + v134 := randStringThetest(r) + this.Field14 = &v134 + case 8: + v135 := r.Intn(100) + this.Field15 = make([]byte, v135) + for i := 0; i < v135; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + return this +} + +func NewPopulatedNinOptStructUnion(r randyThetest, easy bool) *NinOptStructUnion { + this := &NinOptStructUnion{} + fieldNum := r.Intn(9) + switch fieldNum { + case 0: + v136 := float64(r.Float64()) + if r.Intn(2) == 0 { + v136 *= -1 + } + this.Field1 = &v136 + case 1: + v137 := float32(r.Float32()) + if r.Intn(2) == 0 { + v137 *= -1 + } + this.Field2 = &v137 + case 2: + this.Field3 = NewPopulatedNidOptNative(r, easy) + case 3: + this.Field4 = NewPopulatedNinOptNative(r, easy) + case 4: + v138 := uint64(uint64(r.Uint32())) + this.Field6 = &v138 + case 5: + v139 := int32(r.Int31()) + if r.Intn(2) == 0 { + v139 *= -1 + } + this.Field7 = &v139 + case 6: + v140 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v140 + case 7: + v141 := randStringThetest(r) + this.Field14 = &v141 + case 8: + v142 := r.Intn(100) + this.Field15 = make([]byte, v142) + for i := 0; i < v142; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + return this +} + +func NewPopulatedNinEmbeddedStructUnion(r randyThetest, easy bool) *NinEmbeddedStructUnion { + this := &NinEmbeddedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + case 1: + this.Field200 = NewPopulatedNinOptNative(r, easy) + case 2: + v143 := bool(bool(r.Intn(2) == 0)) + this.Field210 = &v143 + } + return this +} + +func NewPopulatedNinNestedStructUnion(r randyThetest, easy bool) *NinNestedStructUnion { + this := &NinNestedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.Field1 = NewPopulatedNinOptNativeUnion(r, easy) + case 1: + this.Field2 = NewPopulatedNinOptStructUnion(r, easy) + case 2: + this.Field3 = NewPopulatedNinEmbeddedStructUnion(r, easy) + } + return this +} + +func NewPopulatedTree(r randyThetest, easy bool) *Tree { + this := &Tree{} + fieldNum := r.Intn(102) + switch fieldNum { + case 0: + this.Or = NewPopulatedOrBranch(r, easy) + case 1: + this.And = NewPopulatedAndBranch(r, easy) + case 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101: + this.Leaf = NewPopulatedLeaf(r, easy) + } + return this +} + +func NewPopulatedOrBranch(r randyThetest, easy bool) *OrBranch { + this := &OrBranch{} + v144 := NewPopulatedTree(r, easy) + this.Left = *v144 + v145 := NewPopulatedTree(r, easy) + this.Right = *v145 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedAndBranch(r randyThetest, easy bool) *AndBranch { + this := &AndBranch{} + v146 := NewPopulatedTree(r, easy) + this.Left = *v146 + v147 := NewPopulatedTree(r, easy) + this.Right = *v147 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedLeaf(r randyThetest, easy bool) *Leaf { + this := &Leaf{} + this.Value = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Value *= -1 + } + this.StrValue = randStringThetest(r) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedDeepTree(r randyThetest, easy bool) *DeepTree { + this := &DeepTree{} + fieldNum := r.Intn(102) + switch fieldNum { + case 0: + this.Down = NewPopulatedADeepBranch(r, easy) + case 1: + this.And = NewPopulatedAndDeepBranch(r, easy) + case 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101: + this.Leaf = NewPopulatedDeepLeaf(r, easy) + } + return this +} + +func NewPopulatedADeepBranch(r randyThetest, easy bool) *ADeepBranch { + this := &ADeepBranch{} + v148 := NewPopulatedDeepTree(r, easy) + this.Down = *v148 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedAndDeepBranch(r randyThetest, easy bool) *AndDeepBranch { + this := &AndDeepBranch{} + v149 := NewPopulatedDeepTree(r, easy) + this.Left = *v149 + v150 := NewPopulatedDeepTree(r, easy) + this.Right = *v150 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedDeepLeaf(r randyThetest, easy bool) *DeepLeaf { + this := &DeepLeaf{} + v151 := NewPopulatedTree(r, easy) + this.Tree = *v151 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNil(r randyThetest, easy bool) *Nil { + this := &Nil{} + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 1) + } + return this +} + +func NewPopulatedNidOptEnum(r randyThetest, easy bool) *NidOptEnum { + this := &NidOptEnum{} + this.Field1 = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptEnum(r randyThetest, easy bool) *NinOptEnum { + this := &NinOptEnum{} + if r.Intn(10) != 0 { + v152 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.Field1 = &v152 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNidRepEnum(r randyThetest, easy bool) *NidRepEnum { + this := &NidRepEnum{} + if r.Intn(10) != 0 { + v153 := r.Intn(10) + this.Field1 = make([]TheTestEnum, v153) + for i := 0; i < v153; i++ { + this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinRepEnum(r randyThetest, easy bool) *NinRepEnum { + this := &NinRepEnum{} + if r.Intn(10) != 0 { + v154 := r.Intn(10) + this.Field1 = make([]TheTestEnum, v154) + for i := 0; i < v154; i++ { + this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptEnumDefault(r randyThetest, easy bool) *NinOptEnumDefault { + this := &NinOptEnumDefault{} + if r.Intn(10) != 0 { + v155 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.Field1 = &v155 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedAnotherNinOptEnum(r randyThetest, easy bool) *AnotherNinOptEnum { + this := &AnotherNinOptEnum{} + if r.Intn(10) != 0 { + v156 := AnotherTestEnum([]int32{10, 11}[r.Intn(2)]) + this.Field1 = &v156 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedAnotherNinOptEnumDefault(r randyThetest, easy bool) *AnotherNinOptEnumDefault { + this := &AnotherNinOptEnumDefault{} + if r.Intn(10) != 0 { + v157 := AnotherTestEnum([]int32{10, 11}[r.Intn(2)]) + this.Field1 = &v157 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedTimer(r randyThetest, easy bool) *Timer { + this := &Timer{} + this.Time1 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Time1 *= -1 + } + this.Time2 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Time2 *= -1 + } + v158 := r.Intn(100) + this.Data = make([]byte, v158) + for i := 0; i < v158; i++ { + this.Data[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 4) + } + return this +} + +func NewPopulatedMyExtendable(r randyThetest, easy bool) *MyExtendable { + this := &MyExtendable{} + if r.Intn(10) != 0 { + v159 := int64(r.Int63()) + if r.Intn(2) == 0 { + v159 *= -1 + } + this.Field1 = &v159 + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + fieldNumber := r.Intn(100) + 100 + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 201) + } + return this +} + +func NewPopulatedOtherExtenable(r randyThetest, easy bool) *OtherExtenable { + this := &OtherExtenable{} + if r.Intn(10) != 0 { + this.M = NewPopulatedMyExtendable(r, easy) + } + if r.Intn(10) != 0 { + v160 := int64(r.Int63()) + if r.Intn(2) == 0 { + v160 *= -1 + } + this.Field2 = &v160 + } + if r.Intn(10) != 0 { + v161 := int64(r.Int63()) + if r.Intn(2) == 0 { + v161 *= -1 + } + this.Field13 = &v161 + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + eIndex := r.Intn(2) + fieldNumber := 0 + switch eIndex { + case 0: + fieldNumber = r.Intn(3) + 14 + case 1: + fieldNumber = r.Intn(3) + 10 + } + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 18) + } + return this +} + +func NewPopulatedNestedDefinition(r randyThetest, easy bool) *NestedDefinition { + this := &NestedDefinition{} + if r.Intn(10) != 0 { + v162 := int64(r.Int63()) + if r.Intn(2) == 0 { + v162 *= -1 + } + this.Field1 = &v162 + } + if r.Intn(10) != 0 { + v163 := NestedDefinition_NestedEnum([]int32{1}[r.Intn(1)]) + this.EnumField = &v163 + } + if r.Intn(10) != 0 { + this.NNM = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if r.Intn(10) != 0 { + this.NM = NewPopulatedNestedDefinition_NestedMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 5) + } + return this +} + +func NewPopulatedNestedDefinition_NestedMessage(r randyThetest, easy bool) *NestedDefinition_NestedMessage { + this := &NestedDefinition_NestedMessage{} + if r.Intn(10) != 0 { + v164 := uint64(uint64(r.Uint32())) + this.NestedField1 = &v164 + } + if r.Intn(10) != 0 { + this.NNM = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r randyThetest, easy bool) *NestedDefinition_NestedMessage_NestedNestedMsg { + this := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if r.Intn(10) != 0 { + v165 := randStringThetest(r) + this.NestedNestedField1 = &v165 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 11) + } + return this +} + +func NewPopulatedNestedScope(r randyThetest, easy bool) *NestedScope { + this := &NestedScope{} + if r.Intn(10) != 0 { + this.A = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if r.Intn(10) != 0 { + v166 := NestedDefinition_NestedEnum([]int32{1}[r.Intn(1)]) + this.B = &v166 + } + if r.Intn(10) != 0 { + this.C = NewPopulatedNestedDefinition_NestedMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 4) + } + return this +} + +func NewPopulatedNinOptNativeDefault(r randyThetest, easy bool) *NinOptNativeDefault { + this := &NinOptNativeDefault{} + if r.Intn(10) != 0 { + v167 := float64(r.Float64()) + if r.Intn(2) == 0 { + v167 *= -1 + } + this.Field1 = &v167 + } + if r.Intn(10) != 0 { + v168 := float32(r.Float32()) + if r.Intn(2) == 0 { + v168 *= -1 + } + this.Field2 = &v168 + } + if r.Intn(10) != 0 { + v169 := int32(r.Int31()) + if r.Intn(2) == 0 { + v169 *= -1 + } + this.Field3 = &v169 + } + if r.Intn(10) != 0 { + v170 := int64(r.Int63()) + if r.Intn(2) == 0 { + v170 *= -1 + } + this.Field4 = &v170 + } + if r.Intn(10) != 0 { + v171 := uint32(r.Uint32()) + this.Field5 = &v171 + } + if r.Intn(10) != 0 { + v172 := uint64(uint64(r.Uint32())) + this.Field6 = &v172 + } + if r.Intn(10) != 0 { + v173 := int32(r.Int31()) + if r.Intn(2) == 0 { + v173 *= -1 + } + this.Field7 = &v173 + } + if r.Intn(10) != 0 { + v174 := int64(r.Int63()) + if r.Intn(2) == 0 { + v174 *= -1 + } + this.Field8 = &v174 + } + if r.Intn(10) != 0 { + v175 := uint32(r.Uint32()) + this.Field9 = &v175 + } + if r.Intn(10) != 0 { + v176 := int32(r.Int31()) + if r.Intn(2) == 0 { + v176 *= -1 + } + this.Field10 = &v176 + } + if r.Intn(10) != 0 { + v177 := uint64(uint64(r.Uint32())) + this.Field11 = &v177 + } + if r.Intn(10) != 0 { + v178 := int64(r.Int63()) + if r.Intn(2) == 0 { + v178 *= -1 + } + this.Field12 = &v178 + } + if r.Intn(10) != 0 { + v179 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v179 + } + if r.Intn(10) != 0 { + v180 := randStringThetest(r) + this.Field14 = &v180 + } + if r.Intn(10) != 0 { + v181 := r.Intn(100) + this.Field15 = make([]byte, v181) + for i := 0; i < v181; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomContainer(r randyThetest, easy bool) *CustomContainer { + this := &CustomContainer{} + v182 := NewPopulatedNidOptCustom(r, easy) + this.CustomStruct = *v182 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedCustomNameNidOptNative(r randyThetest, easy bool) *CustomNameNidOptNative { + this := &CustomNameNidOptNative{} + this.FieldA = float64(r.Float64()) + if r.Intn(2) == 0 { + this.FieldA *= -1 + } + this.FieldB = float32(r.Float32()) + if r.Intn(2) == 0 { + this.FieldB *= -1 + } + this.FieldC = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldC *= -1 + } + this.FieldD = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldD *= -1 + } + this.FieldE = uint32(r.Uint32()) + this.FieldF = uint64(uint64(r.Uint32())) + this.FieldG = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldG *= -1 + } + this.FieldH = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldH *= -1 + } + this.FieldI = uint32(r.Uint32()) + this.FieldJ = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldJ *= -1 + } + this.FieldK = uint64(uint64(r.Uint32())) + this.FieldL = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldL *= -1 + } + this.FieldM = bool(bool(r.Intn(2) == 0)) + this.FieldN = randStringThetest(r) + v183 := r.Intn(100) + this.FieldO = make([]byte, v183) + for i := 0; i < v183; i++ { + this.FieldO[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinOptNative(r randyThetest, easy bool) *CustomNameNinOptNative { + this := &CustomNameNinOptNative{} + if r.Intn(10) != 0 { + v184 := float64(r.Float64()) + if r.Intn(2) == 0 { + v184 *= -1 + } + this.FieldA = &v184 + } + if r.Intn(10) != 0 { + v185 := float32(r.Float32()) + if r.Intn(2) == 0 { + v185 *= -1 + } + this.FieldB = &v185 + } + if r.Intn(10) != 0 { + v186 := int32(r.Int31()) + if r.Intn(2) == 0 { + v186 *= -1 + } + this.FieldC = &v186 + } + if r.Intn(10) != 0 { + v187 := int64(r.Int63()) + if r.Intn(2) == 0 { + v187 *= -1 + } + this.FieldD = &v187 + } + if r.Intn(10) != 0 { + v188 := uint32(r.Uint32()) + this.FieldE = &v188 + } + if r.Intn(10) != 0 { + v189 := uint64(uint64(r.Uint32())) + this.FieldF = &v189 + } + if r.Intn(10) != 0 { + v190 := int32(r.Int31()) + if r.Intn(2) == 0 { + v190 *= -1 + } + this.FieldG = &v190 + } + if r.Intn(10) != 0 { + v191 := int64(r.Int63()) + if r.Intn(2) == 0 { + v191 *= -1 + } + this.FieldH = &v191 + } + if r.Intn(10) != 0 { + v192 := uint32(r.Uint32()) + this.FieldI = &v192 + } + if r.Intn(10) != 0 { + v193 := int32(r.Int31()) + if r.Intn(2) == 0 { + v193 *= -1 + } + this.FieldJ = &v193 + } + if r.Intn(10) != 0 { + v194 := uint64(uint64(r.Uint32())) + this.FieldK = &v194 + } + if r.Intn(10) != 0 { + v195 := int64(r.Int63()) + if r.Intn(2) == 0 { + v195 *= -1 + } + this.FielL = &v195 + } + if r.Intn(10) != 0 { + v196 := bool(bool(r.Intn(2) == 0)) + this.FieldM = &v196 + } + if r.Intn(10) != 0 { + v197 := randStringThetest(r) + this.FieldN = &v197 + } + if r.Intn(10) != 0 { + v198 := r.Intn(100) + this.FieldO = make([]byte, v198) + for i := 0; i < v198; i++ { + this.FieldO[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinRepNative(r randyThetest, easy bool) *CustomNameNinRepNative { + this := &CustomNameNinRepNative{} + if r.Intn(10) != 0 { + v199 := r.Intn(100) + this.FieldA = make([]float64, v199) + for i := 0; i < v199; i++ { + this.FieldA[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.FieldA[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v200 := r.Intn(100) + this.FieldB = make([]float32, v200) + for i := 0; i < v200; i++ { + this.FieldB[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.FieldB[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v201 := r.Intn(100) + this.FieldC = make([]int32, v201) + for i := 0; i < v201; i++ { + this.FieldC[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldC[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v202 := r.Intn(100) + this.FieldD = make([]int64, v202) + for i := 0; i < v202; i++ { + this.FieldD[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldD[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v203 := r.Intn(100) + this.FieldE = make([]uint32, v203) + for i := 0; i < v203; i++ { + this.FieldE[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v204 := r.Intn(100) + this.FieldF = make([]uint64, v204) + for i := 0; i < v204; i++ { + this.FieldF[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v205 := r.Intn(100) + this.FieldG = make([]int32, v205) + for i := 0; i < v205; i++ { + this.FieldG[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldG[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v206 := r.Intn(100) + this.FieldH = make([]int64, v206) + for i := 0; i < v206; i++ { + this.FieldH[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldH[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v207 := r.Intn(100) + this.FieldI = make([]uint32, v207) + for i := 0; i < v207; i++ { + this.FieldI[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v208 := r.Intn(100) + this.FieldJ = make([]int32, v208) + for i := 0; i < v208; i++ { + this.FieldJ[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldJ[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v209 := r.Intn(100) + this.FieldK = make([]uint64, v209) + for i := 0; i < v209; i++ { + this.FieldK[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v210 := r.Intn(100) + this.FieldL = make([]int64, v210) + for i := 0; i < v210; i++ { + this.FieldL[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldL[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v211 := r.Intn(100) + this.FieldM = make([]bool, v211) + for i := 0; i < v211; i++ { + this.FieldM[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v212 := r.Intn(10) + this.FieldN = make([]string, v212) + for i := 0; i < v212; i++ { + this.FieldN[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v213 := r.Intn(100) + this.FieldO = make([][]byte, v213) + for i := 0; i < v213; i++ { + v214 := r.Intn(100) + this.FieldO[i] = make([]byte, v214) + for j := 0; j < v214; j++ { + this.FieldO[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinStruct(r randyThetest, easy bool) *CustomNameNinStruct { + this := &CustomNameNinStruct{} + if r.Intn(10) != 0 { + v215 := float64(r.Float64()) + if r.Intn(2) == 0 { + v215 *= -1 + } + this.FieldA = &v215 + } + if r.Intn(10) != 0 { + v216 := float32(r.Float32()) + if r.Intn(2) == 0 { + v216 *= -1 + } + this.FieldB = &v216 + } + if r.Intn(10) != 0 { + this.FieldC = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v217 := r.Intn(10) + this.FieldD = make([]*NinOptNative, v217) + for i := 0; i < v217; i++ { + this.FieldD[i] = NewPopulatedNinOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v218 := uint64(uint64(r.Uint32())) + this.FieldE = &v218 + } + if r.Intn(10) != 0 { + v219 := int32(r.Int31()) + if r.Intn(2) == 0 { + v219 *= -1 + } + this.FieldF = &v219 + } + if r.Intn(10) != 0 { + this.FieldG = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v220 := bool(bool(r.Intn(2) == 0)) + this.FieldH = &v220 + } + if r.Intn(10) != 0 { + v221 := randStringThetest(r) + this.FieldI = &v221 + } + if r.Intn(10) != 0 { + v222 := r.Intn(100) + this.FieldJ = make([]byte, v222) + for i := 0; i < v222; i++ { + this.FieldJ[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameCustomType(r randyThetest, easy bool) *CustomNameCustomType { + this := &CustomNameCustomType{} + if r.Intn(10) != 0 { + this.FieldA = NewPopulatedUuid(r) + } + if r.Intn(10) != 0 { + this.FieldB = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + } + if r.Intn(10) != 0 { + v223 := r.Intn(10) + this.FieldC = make([]Uuid, v223) + for i := 0; i < v223; i++ { + v224 := NewPopulatedUuid(r) + this.FieldC[i] = *v224 + } + } + if r.Intn(10) != 0 { + v225 := r.Intn(10) + this.FieldD = make([]github_com_gogo_protobuf_test_custom.Uint128, v225) + for i := 0; i < v225; i++ { + v226 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.FieldD[i] = *v226 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 5) + } + return this +} + +func NewPopulatedCustomNameNinEmbeddedStructUnion(r randyThetest, easy bool) *CustomNameNinEmbeddedStructUnion { + this := &CustomNameNinEmbeddedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + case 1: + this.FieldA = NewPopulatedNinOptNative(r, easy) + case 2: + v227 := bool(bool(r.Intn(2) == 0)) + this.FieldB = &v227 + } + return this +} + +func NewPopulatedCustomNameEnum(r randyThetest, easy bool) *CustomNameEnum { + this := &CustomNameEnum{} + if r.Intn(10) != 0 { + v228 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.FieldA = &v228 + } + if r.Intn(10) != 0 { + v229 := r.Intn(10) + this.FieldB = make([]TheTestEnum, v229) + for i := 0; i < v229; i++ { + this.FieldB[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNoExtensionsMap(r randyThetest, easy bool) *NoExtensionsMap { + this := &NoExtensionsMap{} + if r.Intn(10) != 0 { + v230 := int64(r.Int63()) + if r.Intn(2) == 0 { + v230 *= -1 + } + this.Field1 = &v230 + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + fieldNumber := r.Intn(100) + 100 + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 201) + } + return this +} + +func NewPopulatedUnrecognized(r randyThetest, easy bool) *Unrecognized { + this := &Unrecognized{} + if r.Intn(10) != 0 { + v231 := randStringThetest(r) + this.Field1 = &v231 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedUnrecognizedWithInner(r randyThetest, easy bool) *UnrecognizedWithInner { + this := &UnrecognizedWithInner{} + if r.Intn(10) != 0 { + v232 := r.Intn(10) + this.Embedded = make([]*UnrecognizedWithInner_Inner, v232) + for i := 0; i < v232; i++ { + this.Embedded[i] = NewPopulatedUnrecognizedWithInner_Inner(r, easy) + } + } + if r.Intn(10) != 0 { + v233 := randStringThetest(r) + this.Field2 = &v233 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedUnrecognizedWithInner_Inner(r randyThetest, easy bool) *UnrecognizedWithInner_Inner { + this := &UnrecognizedWithInner_Inner{} + if r.Intn(10) != 0 { + v234 := uint32(r.Uint32()) + this.Field1 = &v234 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedUnrecognizedWithEmbed(r randyThetest, easy bool) *UnrecognizedWithEmbed { + this := &UnrecognizedWithEmbed{} + v235 := NewPopulatedUnrecognizedWithEmbed_Embedded(r, easy) + this.UnrecognizedWithEmbed_Embedded = *v235 + if r.Intn(10) != 0 { + v236 := randStringThetest(r) + this.Field2 = &v236 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedUnrecognizedWithEmbed_Embedded(r randyThetest, easy bool) *UnrecognizedWithEmbed_Embedded { + this := &UnrecognizedWithEmbed_Embedded{} + if r.Intn(10) != 0 { + v237 := uint32(r.Uint32()) + this.Field1 = &v237 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +type randyThetest interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneThetest(r randyThetest) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringThetest(r randyThetest) string { + v238 := r.Intn(100) + tmps := make([]rune, v238) + for i := 0; i < v238; i++ { + tmps[i] = randUTF8RuneThetest(r) + } + return string(tmps) +} +func randUnrecognizedThetest(r randyThetest, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldThetest(data, r, fieldNumber, wire) + } + return data +} +func randFieldThetest(data []byte, r randyThetest, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateThetest(data, uint64(key)) + v239 := r.Int63() + if r.Intn(2) == 0 { + v239 *= -1 + } + data = encodeVarintPopulateThetest(data, uint64(v239)) + case 1: + data = encodeVarintPopulateThetest(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateThetest(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateThetest(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateThetest(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateThetest(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *NidOptNative) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + n += 1 + sovThetest(uint64(m.Field3)) + n += 1 + sovThetest(uint64(m.Field4)) + n += 1 + sovThetest(uint64(m.Field5)) + n += 1 + sovThetest(uint64(m.Field6)) + n += 1 + sozThetest(uint64(m.Field7)) + n += 1 + sozThetest(uint64(m.Field8)) + n += 5 + n += 5 + n += 9 + n += 9 + n += 2 + l = len(m.Field14) + n += 1 + l + sovThetest(uint64(l)) + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNative) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + n += 1 + sozThetest(uint64(*m.Field8)) + } + if m.Field9 != nil { + n += 5 + } + if m.Field10 != nil { + n += 5 + } + if m.Field11 != nil { + n += 9 + } + if m.Field12 != nil { + n += 9 + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field5) > 0 { + for _, e := range m.Field5 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field9) > 0 { + n += 5 * len(m.Field9) + } + if len(m.Field10) > 0 { + n += 5 * len(m.Field10) + } + if len(m.Field11) > 0 { + n += 9 * len(m.Field11) + } + if len(m.Field12) > 0 { + n += 9 * len(m.Field12) + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field5) > 0 { + for _, e := range m.Field5 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field9) > 0 { + n += 5 * len(m.Field9) + } + if len(m.Field10) > 0 { + n += 5 * len(m.Field10) + } + if len(m.Field11) > 0 { + n += 9 * len(m.Field11) + } + if len(m.Field12) > 0 { + n += 9 * len(m.Field12) + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepPackedNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 1 + sovThetest(uint64(len(m.Field1)*8)) + len(m.Field1)*8 + } + if len(m.Field2) > 0 { + n += 1 + sovThetest(uint64(len(m.Field2)*4)) + len(m.Field2)*4 + } + if len(m.Field3) > 0 { + l = 0 + for _, e := range m.Field3 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field4) > 0 { + l = 0 + for _, e := range m.Field4 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field5) > 0 { + l = 0 + for _, e := range m.Field5 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field6) > 0 { + l = 0 + for _, e := range m.Field6 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field7) > 0 { + l = 0 + for _, e := range m.Field7 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field8) > 0 { + l = 0 + for _, e := range m.Field8 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field9) > 0 { + n += 1 + sovThetest(uint64(len(m.Field9)*4)) + len(m.Field9)*4 + } + if len(m.Field10) > 0 { + n += 1 + sovThetest(uint64(len(m.Field10)*4)) + len(m.Field10)*4 + } + if len(m.Field11) > 0 { + n += 1 + sovThetest(uint64(len(m.Field11)*8)) + len(m.Field11)*8 + } + if len(m.Field12) > 0 { + n += 1 + sovThetest(uint64(len(m.Field12)*8)) + len(m.Field12)*8 + } + if len(m.Field13) > 0 { + n += 1 + sovThetest(uint64(len(m.Field13))) + len(m.Field13)*1 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepPackedNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 1 + sovThetest(uint64(len(m.Field1)*8)) + len(m.Field1)*8 + } + if len(m.Field2) > 0 { + n += 1 + sovThetest(uint64(len(m.Field2)*4)) + len(m.Field2)*4 + } + if len(m.Field3) > 0 { + l = 0 + for _, e := range m.Field3 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field4) > 0 { + l = 0 + for _, e := range m.Field4 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field5) > 0 { + l = 0 + for _, e := range m.Field5 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field6) > 0 { + l = 0 + for _, e := range m.Field6 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field7) > 0 { + l = 0 + for _, e := range m.Field7 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field8) > 0 { + l = 0 + for _, e := range m.Field8 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field9) > 0 { + n += 1 + sovThetest(uint64(len(m.Field9)*4)) + len(m.Field9)*4 + } + if len(m.Field10) > 0 { + n += 1 + sovThetest(uint64(len(m.Field10)*4)) + len(m.Field10)*4 + } + if len(m.Field11) > 0 { + n += 1 + sovThetest(uint64(len(m.Field11)*8)) + len(m.Field11)*8 + } + if len(m.Field12) > 0 { + n += 1 + sovThetest(uint64(len(m.Field12)*8)) + len(m.Field12)*8 + } + if len(m.Field13) > 0 { + n += 1 + sovThetest(uint64(len(m.Field13))) + len(m.Field13)*1 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptStruct) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + n += 1 + sovThetest(uint64(m.Field6)) + n += 1 + sozThetest(uint64(m.Field7)) + l = m.Field8.Size() + n += 1 + l + sovThetest(uint64(l)) + n += 2 + l = len(m.Field14) + n += 1 + l + sovThetest(uint64(l)) + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptStruct) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field4 != nil { + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + l = m.Field8.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepStruct) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepStruct) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidEmbeddedStruct) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + n += 3 + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinEmbeddedStruct) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field200 != nil { + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.Field210 != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidNestedStruct) Size() (n int) { + var l int + _ = l + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + if len(m.Field2) > 0 { + for _, e := range m.Field2 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinNestedStruct) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.Field2) > 0 { + for _, e := range m.Field2 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptCustom) Size() (n int) { + var l int + _ = l + l = m.Id.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomDash) Size() (n int) { + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptCustom) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepCustom) Size() (n int) { + var l int + _ = l + if len(m.Id) > 0 { + for _, e := range m.Id { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Value) > 0 { + for _, e := range m.Value { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepCustom) Size() (n int) { + var l int + _ = l + if len(m.Id) > 0 { + for _, e := range m.Id { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Value) > 0 { + for _, e := range m.Value { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNativeUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptStructUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field4 != nil { + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinEmbeddedStructUnion) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field200 != nil { + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.Field210 != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinNestedStructUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field2 != nil { + l = m.Field2.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Tree) Size() (n int) { + var l int + _ = l + if m.Or != nil { + l = m.Or.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.And != nil { + l = m.And.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Leaf != nil { + l = m.Leaf.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *OrBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AndBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Leaf) Size() (n int) { + var l int + _ = l + n += 1 + sovThetest(uint64(m.Value)) + l = len(m.StrValue) + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DeepTree) Size() (n int) { + var l int + _ = l + if m.Down != nil { + l = m.Down.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.And != nil { + l = m.And.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Leaf != nil { + l = m.Leaf.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ADeepBranch) Size() (n int) { + var l int + _ = l + l = m.Down.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AndDeepBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DeepLeaf) Size() (n int) { + var l int + _ = l + l = m.Tree.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Nil) Size() (n int) { + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptEnum) Size() (n int) { + var l int + _ = l + n += 1 + sovThetest(uint64(m.Field1)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptEnum) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepEnum) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + for _, e := range m.Field1 { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepEnum) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + for _, e := range m.Field1 { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptEnumDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AnotherNinOptEnum) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AnotherNinOptEnumDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Timer) Size() (n int) { + var l int + _ = l + n += 9 + n += 9 + if m.Data != nil { + l = len(m.Data) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *MyExtendable) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + n += github_com_gogo_protobuf_proto.SizeOfExtensionMap(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *OtherExtenable) Size() (n int) { + var l int + _ = l + if m.M != nil { + l = m.M.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field2 != nil { + n += 1 + sovThetest(uint64(*m.Field2)) + } + if m.Field13 != nil { + n += 1 + sovThetest(uint64(*m.Field13)) + } + if m.XXX_extensions != nil { + n += github_com_gogo_protobuf_proto.SizeOfExtensionMap(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.EnumField != nil { + n += 1 + sovThetest(uint64(*m.EnumField)) + } + if m.NNM != nil { + l = m.NNM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.NM != nil { + l = m.NM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition_NestedMessage) Size() (n int) { + var l int + _ = l + if m.NestedField1 != nil { + n += 9 + } + if m.NNM != nil { + l = m.NNM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Size() (n int) { + var l int + _ = l + if m.NestedNestedField1 != nil { + l = len(*m.NestedNestedField1) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedScope) Size() (n int) { + var l int + _ = l + if m.A != nil { + l = m.A.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.B != nil { + n += 1 + sovThetest(uint64(*m.B)) + } + if m.C != nil { + l = m.C.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNativeDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + n += 1 + sozThetest(uint64(*m.Field8)) + } + if m.Field9 != nil { + n += 5 + } + if m.Field10 != nil { + n += 5 + } + if m.Field11 != nil { + n += 9 + } + if m.Field12 != nil { + n += 9 + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomContainer) Size() (n int) { + var l int + _ = l + l = m.CustomStruct.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNidOptNative) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + n += 1 + sovThetest(uint64(m.FieldC)) + n += 1 + sovThetest(uint64(m.FieldD)) + n += 1 + sovThetest(uint64(m.FieldE)) + n += 1 + sovThetest(uint64(m.FieldF)) + n += 1 + sozThetest(uint64(m.FieldG)) + n += 1 + sozThetest(uint64(m.FieldH)) + n += 5 + n += 5 + n += 9 + n += 9 + n += 2 + l = len(m.FieldN) + n += 1 + l + sovThetest(uint64(l)) + if m.FieldO != nil { + l = len(m.FieldO) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinOptNative) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 9 + } + if m.FieldB != nil { + n += 5 + } + if m.FieldC != nil { + n += 1 + sovThetest(uint64(*m.FieldC)) + } + if m.FieldD != nil { + n += 1 + sovThetest(uint64(*m.FieldD)) + } + if m.FieldE != nil { + n += 1 + sovThetest(uint64(*m.FieldE)) + } + if m.FieldF != nil { + n += 1 + sovThetest(uint64(*m.FieldF)) + } + if m.FieldG != nil { + n += 1 + sozThetest(uint64(*m.FieldG)) + } + if m.FieldH != nil { + n += 1 + sozThetest(uint64(*m.FieldH)) + } + if m.FieldI != nil { + n += 5 + } + if m.FieldJ != nil { + n += 5 + } + if m.FieldK != nil { + n += 9 + } + if m.FielL != nil { + n += 9 + } + if m.FieldM != nil { + n += 2 + } + if m.FieldN != nil { + l = len(*m.FieldN) + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldO != nil { + l = len(m.FieldO) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinRepNative) Size() (n int) { + var l int + _ = l + if len(m.FieldA) > 0 { + n += 9 * len(m.FieldA) + } + if len(m.FieldB) > 0 { + n += 5 * len(m.FieldB) + } + if len(m.FieldC) > 0 { + for _, e := range m.FieldC { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldE) > 0 { + for _, e := range m.FieldE { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldF) > 0 { + for _, e := range m.FieldF { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldG) > 0 { + for _, e := range m.FieldG { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.FieldH) > 0 { + for _, e := range m.FieldH { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.FieldI) > 0 { + n += 5 * len(m.FieldI) + } + if len(m.FieldJ) > 0 { + n += 5 * len(m.FieldJ) + } + if len(m.FieldK) > 0 { + n += 9 * len(m.FieldK) + } + if len(m.FieldL) > 0 { + n += 9 * len(m.FieldL) + } + if len(m.FieldM) > 0 { + n += 2 * len(m.FieldM) + } + if len(m.FieldN) > 0 { + for _, s := range m.FieldN { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.FieldO) > 0 { + for _, b := range m.FieldO { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinStruct) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 9 + } + if m.FieldB != nil { + n += 5 + } + if m.FieldC != nil { + l = m.FieldC.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.FieldE != nil { + n += 1 + sovThetest(uint64(*m.FieldE)) + } + if m.FieldF != nil { + n += 1 + sozThetest(uint64(*m.FieldF)) + } + if m.FieldG != nil { + l = m.FieldG.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldH != nil { + n += 2 + } + if m.FieldI != nil { + l = len(*m.FieldI) + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldJ != nil { + l = len(m.FieldJ) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameCustomType) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + l = m.FieldA.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldB != nil { + l = m.FieldB.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.FieldC) > 0 { + for _, e := range m.FieldC { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinEmbeddedStructUnion) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldA != nil { + l = m.FieldA.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.FieldB != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameEnum) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 1 + sovThetest(uint64(*m.FieldA)) + } + if len(m.FieldB) > 0 { + for _, e := range m.FieldB { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NoExtensionsMap) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + n += len(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Unrecognized) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = len(*m.Field1) + n += 1 + l + sovThetest(uint64(l)) + } + return n +} + +func (m *UnrecognizedWithInner) Size() (n int) { + var l int + _ = l + if len(m.Embedded) > 0 { + for _, e := range m.Embedded { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.Field2 != nil { + l = len(*m.Field2) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UnrecognizedWithInner_Inner) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + return n +} + +func (m *UnrecognizedWithEmbed) Size() (n int) { + var l int + _ = l + l = m.UnrecognizedWithEmbed_Embedded.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.Field2 != nil { + l = len(*m.Field2) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UnrecognizedWithEmbed_Embedded) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + return n +} + +func sovThetest(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozThetest(x uint64) (n int) { + return sovThetest(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *NidOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNative{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + valueToStringThetest(this.Field8) + `,`, + `Field9:` + valueToStringThetest(this.Field9) + `,`, + `Field10:` + valueToStringThetest(this.Field10) + `,`, + `Field11:` + valueToStringThetest(this.Field11) + `,`, + `Field12:` + valueToStringThetest(this.Field12) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepPackedNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepPackedNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepPackedNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepPackedNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(strings.Replace(this.Field3.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field4:` + strings.Replace(strings.Replace(this.Field4.String(), "NinOptNative", "NinOptNative", 1), `&`, ``, 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(strings.Replace(this.Field8.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptStruct{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field4:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1), `&`, ``, 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidEmbeddedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidEmbeddedStruct{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(strings.Replace(this.Field200.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field210:` + fmt.Sprintf("%v", this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinEmbeddedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinEmbeddedStruct{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(fmt.Sprintf("%v", this.Field200), "NidOptNative", "NidOptNative", 1) + `,`, + `Field210:` + valueToStringThetest(this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidNestedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidNestedStruct{`, + `Field1:` + strings.Replace(strings.Replace(this.Field1.String(), "NidOptStruct", "NidOptStruct", 1), `&`, ``, 1) + `,`, + `Field2:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field2), "NidRepStruct", "NidRepStruct", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinNestedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinNestedStruct{`, + `Field1:` + strings.Replace(fmt.Sprintf("%v", this.Field1), "NinOptStruct", "NinOptStruct", 1) + `,`, + `Field2:` + strings.Replace(fmt.Sprintf("%v", this.Field2), "NinRepStruct", "NinRepStruct", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomDash) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomDash{`, + `Value:` + valueToStringThetest(this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptCustom{`, + `Id:` + valueToStringThetest(this.Id) + `,`, + `Value:` + valueToStringThetest(this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNativeUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNativeUnion{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptStructUnion{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinEmbeddedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinEmbeddedStructUnion{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(fmt.Sprintf("%v", this.Field200), "NinOptNative", "NinOptNative", 1) + `,`, + `Field210:` + valueToStringThetest(this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinNestedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinNestedStructUnion{`, + `Field1:` + strings.Replace(fmt.Sprintf("%v", this.Field1), "NinOptNativeUnion", "NinOptNativeUnion", 1) + `,`, + `Field2:` + strings.Replace(fmt.Sprintf("%v", this.Field2), "NinOptStructUnion", "NinOptStructUnion", 1) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NinEmbeddedStructUnion", "NinEmbeddedStructUnion", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Tree) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Tree{`, + `Or:` + strings.Replace(fmt.Sprintf("%v", this.Or), "OrBranch", "OrBranch", 1) + `,`, + `And:` + strings.Replace(fmt.Sprintf("%v", this.And), "AndBranch", "AndBranch", 1) + `,`, + `Leaf:` + strings.Replace(fmt.Sprintf("%v", this.Leaf), "Leaf", "Leaf", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OrBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OrBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AndBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AndBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Leaf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Leaf{`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `StrValue:` + fmt.Sprintf("%v", this.StrValue) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *DeepTree) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DeepTree{`, + `Down:` + strings.Replace(fmt.Sprintf("%v", this.Down), "ADeepBranch", "ADeepBranch", 1) + `,`, + `And:` + strings.Replace(fmt.Sprintf("%v", this.And), "AndDeepBranch", "AndDeepBranch", 1) + `,`, + `Leaf:` + strings.Replace(fmt.Sprintf("%v", this.Leaf), "DeepLeaf", "DeepLeaf", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ADeepBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ADeepBranch{`, + `Down:` + strings.Replace(strings.Replace(this.Down.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AndDeepBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AndDeepBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *DeepLeaf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DeepLeaf{`, + `Tree:` + strings.Replace(strings.Replace(this.Tree.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Nil) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Nil{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptEnum{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptEnumDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptEnumDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AnotherNinOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnotherNinOptEnum{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AnotherNinOptEnumDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnotherNinOptEnumDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Timer) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Timer{`, + `Time1:` + fmt.Sprintf("%v", this.Time1) + `,`, + `Time2:` + fmt.Sprintf("%v", this.Time2) + `,`, + `Data:` + fmt.Sprintf("%v", this.Data) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *MyExtendable) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&MyExtendable{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsMap(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OtherExtenable) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OtherExtenable{`, + `M:` + strings.Replace(fmt.Sprintf("%v", this.M), "MyExtendable", "MyExtendable", 1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsMap(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `EnumField:` + valueToStringThetest(this.EnumField) + `,`, + `NNM:` + strings.Replace(fmt.Sprintf("%v", this.NNM), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `NM:` + strings.Replace(fmt.Sprintf("%v", this.NM), "NestedDefinition_NestedMessage", "NestedDefinition_NestedMessage", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition_NestedMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition_NestedMessage{`, + `NestedField1:` + valueToStringThetest(this.NestedField1) + `,`, + `NNM:` + strings.Replace(fmt.Sprintf("%v", this.NNM), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition_NestedMessage_NestedNestedMsg{`, + `NestedNestedField1:` + valueToStringThetest(this.NestedNestedField1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedScope) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedScope{`, + `A:` + strings.Replace(fmt.Sprintf("%v", this.A), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `B:` + valueToStringThetest(this.B) + `,`, + `C:` + strings.Replace(fmt.Sprintf("%v", this.C), "NestedDefinition_NestedMessage", "NestedDefinition_NestedMessage", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNativeDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNativeDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + valueToStringThetest(this.Field8) + `,`, + `Field9:` + valueToStringThetest(this.Field9) + `,`, + `Field10:` + valueToStringThetest(this.Field10) + `,`, + `Field11:` + valueToStringThetest(this.Field11) + `,`, + `Field12:` + valueToStringThetest(this.Field12) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomContainer) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomContainer{`, + `CustomStruct:` + strings.Replace(strings.Replace(this.CustomStruct.String(), "NidOptCustom", "NidOptCustom", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNidOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNidOptNative{`, + `FieldA:` + fmt.Sprintf("%v", this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `FieldE:` + fmt.Sprintf("%v", this.FieldE) + `,`, + `FieldF:` + fmt.Sprintf("%v", this.FieldF) + `,`, + `FieldG:` + fmt.Sprintf("%v", this.FieldG) + `,`, + `FieldH:` + fmt.Sprintf("%v", this.FieldH) + `,`, + `FieldI:` + fmt.Sprintf("%v", this.FieldI) + `,`, + `FieldJ:` + fmt.Sprintf("%v", this.FieldJ) + `,`, + `FieldK:` + fmt.Sprintf("%v", this.FieldK) + `,`, + `FieldL:` + fmt.Sprintf("%v", this.FieldL) + `,`, + `FieldM:` + fmt.Sprintf("%v", this.FieldM) + `,`, + `FieldN:` + fmt.Sprintf("%v", this.FieldN) + `,`, + `FieldO:` + fmt.Sprintf("%v", this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinOptNative{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + valueToStringThetest(this.FieldC) + `,`, + `FieldD:` + valueToStringThetest(this.FieldD) + `,`, + `FieldE:` + valueToStringThetest(this.FieldE) + `,`, + `FieldF:` + valueToStringThetest(this.FieldF) + `,`, + `FieldG:` + valueToStringThetest(this.FieldG) + `,`, + `FieldH:` + valueToStringThetest(this.FieldH) + `,`, + `FieldI:` + valueToStringThetest(this.FieldI) + `,`, + `FieldJ:` + valueToStringThetest(this.FieldJ) + `,`, + `FieldK:` + valueToStringThetest(this.FieldK) + `,`, + `FielL:` + valueToStringThetest(this.FielL) + `,`, + `FieldM:` + valueToStringThetest(this.FieldM) + `,`, + `FieldN:` + valueToStringThetest(this.FieldN) + `,`, + `FieldO:` + valueToStringThetest(this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinRepNative{`, + `FieldA:` + fmt.Sprintf("%v", this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `FieldE:` + fmt.Sprintf("%v", this.FieldE) + `,`, + `FieldF:` + fmt.Sprintf("%v", this.FieldF) + `,`, + `FieldG:` + fmt.Sprintf("%v", this.FieldG) + `,`, + `FieldH:` + fmt.Sprintf("%v", this.FieldH) + `,`, + `FieldI:` + fmt.Sprintf("%v", this.FieldI) + `,`, + `FieldJ:` + fmt.Sprintf("%v", this.FieldJ) + `,`, + `FieldK:` + fmt.Sprintf("%v", this.FieldK) + `,`, + `FieldL:` + fmt.Sprintf("%v", this.FieldL) + `,`, + `FieldM:` + fmt.Sprintf("%v", this.FieldM) + `,`, + `FieldN:` + fmt.Sprintf("%v", this.FieldN) + `,`, + `FieldO:` + fmt.Sprintf("%v", this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinStruct{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + strings.Replace(fmt.Sprintf("%v", this.FieldC), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldD:` + strings.Replace(fmt.Sprintf("%v", this.FieldD), "NinOptNative", "NinOptNative", 1) + `,`, + `FieldE:` + valueToStringThetest(this.FieldE) + `,`, + `FieldF:` + valueToStringThetest(this.FieldF) + `,`, + `FieldG:` + strings.Replace(fmt.Sprintf("%v", this.FieldG), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldH:` + valueToStringThetest(this.FieldH) + `,`, + `FieldI:` + valueToStringThetest(this.FieldI) + `,`, + `FieldJ:` + valueToStringThetest(this.FieldJ) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameCustomType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameCustomType{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinEmbeddedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinEmbeddedStructUnion{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldA:` + strings.Replace(fmt.Sprintf("%v", this.FieldA), "NinOptNative", "NinOptNative", 1) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameEnum{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NoExtensionsMap) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NoExtensionsMap{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsBytes(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Unrecognized) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Unrecognized{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithInner) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithInner{`, + `Embedded:` + strings.Replace(fmt.Sprintf("%v", this.Embedded), "UnrecognizedWithInner_Inner", "UnrecognizedWithInner_Inner", 1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithInner_Inner) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithInner_Inner{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithEmbed) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithEmbed{`, + `UnrecognizedWithEmbed_Embedded:` + strings.Replace(strings.Replace(this.UnrecognizedWithEmbed_Embedded.String(), "UnrecognizedWithEmbed_Embedded", "UnrecognizedWithEmbed_Embedded", 1), `&`, ``, 1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithEmbed_Embedded) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithEmbed_Embedded{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func valueToStringThetest(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (this *NinOptNativeUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + if this.Field4 != nil { + return this.Field4 + } + if this.Field5 != nil { + return this.Field5 + } + if this.Field6 != nil { + return this.Field6 + } + if this.Field13 != nil { + return this.Field13 + } + if this.Field14 != nil { + return this.Field14 + } + if this.Field15 != nil { + return this.Field15 + } + return nil +} + +func (this *NinOptNativeUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *float64: + this.Field1 = vt + case *float32: + this.Field2 = vt + case *int32: + this.Field3 = vt + case *int64: + this.Field4 = vt + case *uint32: + this.Field5 = vt + case *uint64: + this.Field6 = vt + case *bool: + this.Field13 = vt + case *string: + this.Field14 = vt + case []byte: + this.Field15 = vt + default: + return false + } + return true +} +func (this *NinOptStructUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + if this.Field4 != nil { + return this.Field4 + } + if this.Field6 != nil { + return this.Field6 + } + if this.Field7 != nil { + return this.Field7 + } + if this.Field13 != nil { + return this.Field13 + } + if this.Field14 != nil { + return this.Field14 + } + if this.Field15 != nil { + return this.Field15 + } + return nil +} + +func (this *NinOptStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *float64: + this.Field1 = vt + case *float32: + this.Field2 = vt + case *NidOptNative: + this.Field3 = vt + case *NinOptNative: + this.Field4 = vt + case *uint64: + this.Field6 = vt + case *int32: + this.Field7 = vt + case *bool: + this.Field13 = vt + case *string: + this.Field14 = vt + case []byte: + this.Field15 = vt + default: + return false + } + return true +} +func (this *NinEmbeddedStructUnion) GetValue() interface{} { + if this.NidOptNative != nil { + return this.NidOptNative + } + if this.Field200 != nil { + return this.Field200 + } + if this.Field210 != nil { + return this.Field210 + } + return nil +} + +func (this *NinEmbeddedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NidOptNative: + this.NidOptNative = vt + case *NinOptNative: + this.Field200 = vt + case *bool: + this.Field210 = vt + default: + return false + } + return true +} +func (this *NinNestedStructUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + return nil +} + +func (this *NinNestedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NinOptNativeUnion: + this.Field1 = vt + case *NinOptStructUnion: + this.Field2 = vt + case *NinEmbeddedStructUnion: + this.Field3 = vt + default: + this.Field1 = new(NinOptNativeUnion) + if set := this.Field1.SetValue(value); set { + return true + } + this.Field1 = nil + this.Field2 = new(NinOptStructUnion) + if set := this.Field2.SetValue(value); set { + return true + } + this.Field2 = nil + this.Field3 = new(NinEmbeddedStructUnion) + if set := this.Field3.SetValue(value); set { + return true + } + this.Field3 = nil + return false + } + return true +} +func (this *Tree) GetValue() interface{} { + if this.Or != nil { + return this.Or + } + if this.And != nil { + return this.And + } + if this.Leaf != nil { + return this.Leaf + } + return nil +} + +func (this *Tree) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *OrBranch: + this.Or = vt + case *AndBranch: + this.And = vt + case *Leaf: + this.Leaf = vt + default: + return false + } + return true +} +func (this *DeepTree) GetValue() interface{} { + if this.Down != nil { + return this.Down + } + if this.And != nil { + return this.And + } + if this.Leaf != nil { + return this.Leaf + } + return nil +} + +func (this *DeepTree) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *ADeepBranch: + this.Down = vt + case *AndDeepBranch: + this.And = vt + case *DeepLeaf: + this.Leaf = vt + default: + return false + } + return true +} +func (this *CustomNameNinEmbeddedStructUnion) GetValue() interface{} { + if this.NidOptNative != nil { + return this.NidOptNative + } + if this.FieldA != nil { + return this.FieldA + } + if this.FieldB != nil { + return this.FieldB + } + return nil +} + +func (this *CustomNameNinEmbeddedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NidOptNative: + this.NidOptNative = vt + case *NinOptNative: + this.FieldA = vt + case *bool: + this.FieldB = vt + default: + return false + } + return true +} +func (m *NidOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field1 = float64(math.Float64frombits(v)) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field2 = float32(math.Float32frombits(v)) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + m.Field3 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field3 |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + m.Field4 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field4 |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + m.Field5 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field5 |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + m.Field6 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field6 |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = int64(v) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + m.Field9 = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + m.Field9 = uint32(data[iNdEx-4]) + m.Field9 |= uint32(data[iNdEx-3]) << 8 + m.Field9 |= uint32(data[iNdEx-2]) << 16 + m.Field9 |= uint32(data[iNdEx-1]) << 24 + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + m.Field10 = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + m.Field10 = int32(data[iNdEx-4]) + m.Field10 |= int32(data[iNdEx-3]) << 8 + m.Field10 |= int32(data[iNdEx-2]) << 16 + m.Field10 |= int32(data[iNdEx-1]) << 24 + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + m.Field11 = 0 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + m.Field11 = uint64(data[iNdEx-8]) + m.Field11 |= uint64(data[iNdEx-7]) << 8 + m.Field11 |= uint64(data[iNdEx-6]) << 16 + m.Field11 |= uint64(data[iNdEx-5]) << 24 + m.Field11 |= uint64(data[iNdEx-4]) << 32 + m.Field11 |= uint64(data[iNdEx-3]) << 40 + m.Field11 |= uint64(data[iNdEx-2]) << 48 + m.Field11 |= uint64(data[iNdEx-1]) << 56 + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + m.Field12 = 0 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + m.Field12 = int64(data[iNdEx-8]) + m.Field12 |= int64(data[iNdEx-7]) << 8 + m.Field12 |= int64(data[iNdEx-6]) << 16 + m.Field12 |= int64(data[iNdEx-5]) << 24 + m.Field12 |= int64(data[iNdEx-4]) << 32 + m.Field12 |= int64(data[iNdEx-3]) << 40 + m.Field12 |= int64(data[iNdEx-2]) << 48 + m.Field12 |= int64(data[iNdEx-1]) << 56 + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = bool(v != 0) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = &v2 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = &v2 + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = &v + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + v2 := int64(v) + m.Field8 = &v2 + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = &v + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = &v + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = &v + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = append(m.Field9, v) + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = append(m.Field10, v) + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = append(m.Field11, v) + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = append(m.Field12, v) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = append(m.Field14, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx)) + copy(m.Field15[len(m.Field15)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = append(m.Field9, v) + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = append(m.Field10, v) + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = append(m.Field11, v) + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = append(m.Field12, v) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = append(m.Field14, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx)) + copy(m.Field15[len(m.Field15)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepPackedNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepPackedNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepPackedNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + } + } else if wireType == 1 { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + case 2: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + } + } else if wireType == 5 { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + case 3: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + case 4: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } + } else if wireType == 0 { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + case 5: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } + } else if wireType == 0 { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + case 6: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + case 7: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + case 8: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + case 9: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = append(m.Field9, v) + } + } else if wireType == 5 { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = append(m.Field9, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + case 10: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = append(m.Field10, v) + } + } else if wireType == 5 { + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = append(m.Field10, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + case 11: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = append(m.Field11, v) + } + } else if wireType == 1 { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = append(m.Field11, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + case 12: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = append(m.Field12, v) + } + } else if wireType == 1 { + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = append(m.Field12, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + case 13: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } + } else if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepPackedNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepPackedNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepPackedNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + } + } else if wireType == 1 { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + case 2: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + } + } else if wireType == 5 { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + case 3: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + case 4: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } + } else if wireType == 0 { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + case 5: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } + } else if wireType == 0 { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + case 6: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + case 7: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + case 8: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + case 9: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = append(m.Field9, v) + } + } else if wireType == 5 { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = append(m.Field9, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + case 10: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = append(m.Field10, v) + } + } else if wireType == 5 { + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = append(m.Field10, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + case 11: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = append(m.Field11, v) + } + } else if wireType == 1 { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = append(m.Field11, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + case 12: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = append(m.Field12, v) + } + } else if wireType == 1 { + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = append(m.Field12, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + case 13: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } + } else if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidOptStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidOptStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidOptStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field1 = float64(math.Float64frombits(v)) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field2 = float32(math.Float32frombits(v)) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field4.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + m.Field6 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field6 |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = v + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field8.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = bool(v != 0) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = &v2 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = &v2 + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field3 == nil { + m.Field3 = &NidOptNative{} + } + if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field4 == nil { + m.Field4 = &NinOptNative{} + } + if err := m.Field4.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field8 == nil { + m.Field8 = &NidOptNative{} + } + if err := m.Field8.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field3 = append(m.Field3, NidOptNative{}) + if err := m.Field3[len(m.Field3)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field4 = append(m.Field4, NinOptNative{}) + if err := m.Field4[len(m.Field4)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field8 = append(m.Field8, NidOptNative{}) + if err := m.Field8[len(m.Field8)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = append(m.Field14, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx)) + copy(m.Field15[len(m.Field15)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field3 = append(m.Field3, &NidOptNative{}) + if err := m.Field3[len(m.Field3)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field4 = append(m.Field4, &NinOptNative{}) + if err := m.Field4[len(m.Field4)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field8 = append(m.Field8, &NidOptNative{}) + if err := m.Field8[len(m.Field8)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = append(m.Field14, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx)) + copy(m.Field15[len(m.Field15)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidEmbeddedStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidEmbeddedStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidEmbeddedStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NidOptNative == nil { + m.NidOptNative = &NidOptNative{} + } + if err := m.NidOptNative.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field200", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field200.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 210: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field210", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field210 = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinEmbeddedStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinEmbeddedStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinEmbeddedStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NidOptNative == nil { + m.NidOptNative = &NidOptNative{} + } + if err := m.NidOptNative.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field200", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field200 == nil { + m.Field200 = &NidOptNative{} + } + if err := m.Field200.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 210: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field210", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field210 = &b + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidNestedStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidNestedStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidNestedStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field1.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field2 = append(m.Field2, NidRepStruct{}) + if err := m.Field2[len(m.Field2)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinNestedStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinNestedStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinNestedStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field1 == nil { + m.Field1 = &NinOptStruct{} + } + if err := m.Field1.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field2 = append(m.Field2, &NinRepStruct{}) + if err := m.Field2[len(m.Field2)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidOptCustom) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidOptCustom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidOptCustom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Id.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Value.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomDash) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomDash: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomDash: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom_dash_type.Bytes + m.Value = &v + if err := m.Value.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptCustom) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptCustom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptCustom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.Id = &v + if err := m.Id.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.Value = &v + if err := m.Value.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepCustom) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepCustom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepCustom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.Id = append(m.Id, v) + if err := m.Id[len(m.Id)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.Value = append(m.Value, v) + if err := m.Value[len(m.Value)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepCustom) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepCustom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepCustom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.Id = append(m.Id, v) + if err := m.Id[len(m.Id)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.Value = append(m.Value, v) + if err := m.Value[len(m.Value)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptNativeUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptNativeUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptNativeUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = &v2 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = &v2 + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = &v + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptStructUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptStructUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptStructUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = &v2 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = &v2 + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field3 == nil { + m.Field3 = &NidOptNative{} + } + if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field4 == nil { + m.Field4 = &NinOptNative{} + } + if err := m.Field4.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinEmbeddedStructUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinEmbeddedStructUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinEmbeddedStructUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NidOptNative == nil { + m.NidOptNative = &NidOptNative{} + } + if err := m.NidOptNative.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field200", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field200 == nil { + m.Field200 = &NinOptNative{} + } + if err := m.Field200.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 210: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field210", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field210 = &b + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinNestedStructUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinNestedStructUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinNestedStructUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field1 == nil { + m.Field1 = &NinOptNativeUnion{} + } + if err := m.Field1.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field2 == nil { + m.Field2 = &NinOptStructUnion{} + } + if err := m.Field2.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field3 == nil { + m.Field3 = &NinEmbeddedStructUnion{} + } + if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Tree) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Tree: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Tree: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Or", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Or == nil { + m.Or = &OrBranch{} + } + if err := m.Or.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field And", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.And == nil { + m.And = &AndBranch{} + } + if err := m.And.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Leaf", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Leaf == nil { + m.Leaf = &Leaf{} + } + if err := m.Leaf.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OrBranch) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OrBranch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OrBranch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Left.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Right.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AndBranch) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AndBranch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AndBranch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Left.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Right.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Leaf) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Leaf: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Leaf: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + m.Value = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Value |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StrValue", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StrValue = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DeepTree) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DeepTree: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeepTree: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Down", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Down == nil { + m.Down = &ADeepBranch{} + } + if err := m.Down.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field And", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.And == nil { + m.And = &AndDeepBranch{} + } + if err := m.And.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Leaf", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Leaf == nil { + m.Leaf = &DeepLeaf{} + } + if err := m.Leaf.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ADeepBranch) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ADeepBranch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ADeepBranch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Down", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Down.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AndDeepBranch) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AndDeepBranch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AndDeepBranch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Left.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Right.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DeepLeaf) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DeepLeaf: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeepLeaf: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tree", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Tree.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Nil) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Nil: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Nil: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidOptEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidOptEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidOptEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + m.Field1 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field1 |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = append(m.Field1, v) + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = append(m.Field1, v) + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptEnumDefault) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptEnumDefault: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptEnumDefault: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnotherNinOptEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnotherNinOptEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnotherNinOptEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v AnotherTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (AnotherTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnotherNinOptEnumDefault) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnotherNinOptEnumDefault: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnotherNinOptEnumDefault: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v AnotherTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (AnotherTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Timer) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Timer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Timer: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Time1", wireType) + } + m.Time1 = 0 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + m.Time1 = int64(data[iNdEx-8]) + m.Time1 |= int64(data[iNdEx-7]) << 8 + m.Time1 |= int64(data[iNdEx-6]) << 16 + m.Time1 |= int64(data[iNdEx-5]) << 24 + m.Time1 |= int64(data[iNdEx-4]) << 32 + m.Time1 |= int64(data[iNdEx-3]) << 40 + m.Time1 |= int64(data[iNdEx-2]) << 48 + m.Time1 |= int64(data[iNdEx-1]) << 56 + case 2: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Time2", wireType) + } + m.Time2 = 0 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + m.Time2 = int64(data[iNdEx-8]) + m.Time2 |= int64(data[iNdEx-7]) << 8 + m.Time2 |= int64(data[iNdEx-6]) << 16 + m.Time2 |= int64(data[iNdEx-5]) << 24 + m.Time2 |= int64(data[iNdEx-4]) << 32 + m.Time2 |= int64(data[iNdEx-3]) << 40 + m.Time2 |= int64(data[iNdEx-2]) << 48 + m.Time2 |= int64(data[iNdEx-1]) << 56 + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MyExtendable) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MyExtendable: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MyExtendable: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + if (fieldNum >= 100) && (fieldNum < 200) { + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + iNdEx -= sizeOfWire + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]github_com_gogo_protobuf_proto.Extension) + } + m.XXX_extensions[int32(fieldNum)] = github_com_gogo_protobuf_proto.NewExtension(data[iNdEx : iNdEx+skippy]) + iNdEx += skippy + } else { + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OtherExtenable) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OtherExtenable: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OtherExtenable: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field M", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.M == nil { + m.M = &MyExtendable{} + } + if err := m.M.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field2 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = &v + default: + if ((fieldNum >= 14) && (fieldNum < 17)) || ((fieldNum >= 10) && (fieldNum < 13)) { + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + iNdEx -= sizeOfWire + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]github_com_gogo_protobuf_proto.Extension) + } + m.XXX_extensions[int32(fieldNum)] = github_com_gogo_protobuf_proto.NewExtension(data[iNdEx : iNdEx+skippy]) + iNdEx += skippy + } else { + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NestedDefinition) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NestedDefinition: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NestedDefinition: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EnumField", wireType) + } + var v NestedDefinition_NestedEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (NestedDefinition_NestedEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.EnumField = &v + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NNM", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NNM == nil { + m.NNM = &NestedDefinition_NestedMessage_NestedNestedMsg{} + } + if err := m.NNM.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NM", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NM == nil { + m.NM = &NestedDefinition_NestedMessage{} + } + if err := m.NM.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NestedDefinition_NestedMessage) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NestedMessage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NestedMessage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field NestedField1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.NestedField1 = &v + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NNM", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NNM == nil { + m.NNM = &NestedDefinition_NestedMessage_NestedNestedMsg{} + } + if err := m.NNM.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NestedNestedMsg: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NestedNestedMsg: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NestedNestedField1", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.NestedNestedField1 = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NestedScope) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NestedScope: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NestedScope: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.A == nil { + m.A = &NestedDefinition_NestedMessage_NestedNestedMsg{} + } + if err := m.A.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var v NestedDefinition_NestedEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (NestedDefinition_NestedEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.B = &v + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field C", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.C == nil { + m.C = &NestedDefinition_NestedMessage{} + } + if err := m.C.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptNativeDefault) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptNativeDefault: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptNativeDefault: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = &v2 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = &v2 + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = &v + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + v2 := int64(v) + m.Field8 = &v2 + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = &v + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = &v + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = &v + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomContainer) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomContainer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomContainer: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CustomStruct", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.CustomStruct.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNidOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNidOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNidOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.FieldA = float64(math.Float64frombits(v)) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.FieldB = float32(math.Float32frombits(v)) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + m.FieldC = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.FieldC |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + m.FieldD = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.FieldD |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) + } + m.FieldE = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.FieldE |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) + } + m.FieldF = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.FieldF |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.FieldG = v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.FieldH = int64(v) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType) + } + m.FieldI = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + m.FieldI = uint32(data[iNdEx-4]) + m.FieldI |= uint32(data[iNdEx-3]) << 8 + m.FieldI |= uint32(data[iNdEx-2]) << 16 + m.FieldI |= uint32(data[iNdEx-1]) << 24 + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType) + } + m.FieldJ = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + m.FieldJ = int32(data[iNdEx-4]) + m.FieldJ |= int32(data[iNdEx-3]) << 8 + m.FieldJ |= int32(data[iNdEx-2]) << 16 + m.FieldJ |= int32(data[iNdEx-1]) << 24 + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldK", wireType) + } + m.FieldK = 0 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + m.FieldK = uint64(data[iNdEx-8]) + m.FieldK |= uint64(data[iNdEx-7]) << 8 + m.FieldK |= uint64(data[iNdEx-6]) << 16 + m.FieldK |= uint64(data[iNdEx-5]) << 24 + m.FieldK |= uint64(data[iNdEx-4]) << 32 + m.FieldK |= uint64(data[iNdEx-3]) << 40 + m.FieldK |= uint64(data[iNdEx-2]) << 48 + m.FieldK |= uint64(data[iNdEx-1]) << 56 + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldL", wireType) + } + m.FieldL = 0 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + m.FieldL = int64(data[iNdEx-8]) + m.FieldL |= int64(data[iNdEx-7]) << 8 + m.FieldL |= int64(data[iNdEx-6]) << 16 + m.FieldL |= int64(data[iNdEx-5]) << 24 + m.FieldL |= int64(data[iNdEx-4]) << 32 + m.FieldL |= int64(data[iNdEx-3]) << 40 + m.FieldL |= int64(data[iNdEx-2]) << 48 + m.FieldL |= int64(data[iNdEx-1]) << 56 + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldM", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldM = bool(v != 0) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldN", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldN = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldO", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldO = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNinOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNinOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNinOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.FieldA = &v2 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.FieldB = &v2 + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldC = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldD = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldE = &v + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldF = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.FieldG = &v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + v2 := int64(v) + m.FieldH = &v2 + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.FieldI = &v + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.FieldJ = &v + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldK", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.FieldK = &v + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FielL", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.FielL = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldM", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.FieldM = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldN", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.FieldN = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldO", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldO = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNinRepNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNinRepNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNinRepNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.FieldA = append(m.FieldA, v2) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.FieldB = append(m.FieldB, v2) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldC = append(m.FieldC, v) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldD = append(m.FieldD, v) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldE = append(m.FieldE, v) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldF = append(m.FieldF, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.FieldG = append(m.FieldG, v) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.FieldH = append(m.FieldH, int64(v)) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.FieldI = append(m.FieldI, v) + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.FieldJ = append(m.FieldJ, v) + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldK", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.FieldK = append(m.FieldK, v) + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldL", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.FieldL = append(m.FieldL, v) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldM", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldM = append(m.FieldM, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldN", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldN = append(m.FieldN, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldO", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldO = append(m.FieldO, make([]byte, postIndex-iNdEx)) + copy(m.FieldO[len(m.FieldO)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNinStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNinStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNinStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.FieldA = &v2 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.FieldB = &v2 + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FieldC == nil { + m.FieldC = &NidOptNative{} + } + if err := m.FieldC.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldD = append(m.FieldD, &NinOptNative{}) + if err := m.FieldD[len(m.FieldD)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldE = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.FieldF = &v + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FieldG == nil { + m.FieldG = &NidOptNative{} + } + if err := m.FieldG.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.FieldH = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.FieldI = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldJ = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameCustomType) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameCustomType: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameCustomType: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.FieldA = &v + if err := m.FieldA.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.FieldB = &v + if err := m.FieldB.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.FieldC = append(m.FieldC, v) + if err := m.FieldC[len(m.FieldC)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.FieldD = append(m.FieldD, v) + if err := m.FieldD[len(m.FieldD)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNinEmbeddedStructUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNinEmbeddedStructUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNinEmbeddedStructUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NidOptNative == nil { + m.NidOptNative = &NidOptNative{} + } + if err := m.NidOptNative.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FieldA == nil { + m.FieldA = &NinOptNative{} + } + if err := m.FieldA.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 210: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.FieldB = &b + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldA = &v + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldB = append(m.FieldB, v) + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NoExtensionsMap) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NoExtensionsMap: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NoExtensionsMap: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + if (fieldNum >= 100) && (fieldNum < 200) { + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + iNdEx -= sizeOfWire + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_extensions = append(m.XXX_extensions, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } else { + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Unrecognized) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Unrecognized: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Unrecognized: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field1 = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnrecognizedWithInner) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UnrecognizedWithInner: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UnrecognizedWithInner: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Embedded", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Embedded = append(m.Embedded, &UnrecognizedWithInner_Inner{}) + if err := m.Embedded[len(m.Embedded)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field2 = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnrecognizedWithInner_Inner) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Inner: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Inner: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnrecognizedWithEmbed) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UnrecognizedWithEmbed: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UnrecognizedWithEmbed: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnrecognizedWithEmbed_Embedded", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.UnrecognizedWithEmbed_Embedded.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field2 = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnrecognizedWithEmbed_Embedded) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Embedded: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Embedded: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipThetest(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowThetest + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowThetest + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowThetest + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthThetest + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowThetest + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipThetest(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthThetest = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowThetest = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both/thetest.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both/thetest.proto new file mode 100644 index 0000000000000000000000000000000000000000..2de4c5add500b53bd31e0ef24655ce5089004ad7 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both/thetest.proto @@ -0,0 +1,584 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package test; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message NidOptNative { + optional double Field1 = 1 [(gogoproto.nullable) = false]; + optional float Field2 = 2 [(gogoproto.nullable) = false]; + optional int32 Field3 = 3 [(gogoproto.nullable) = false]; + optional int64 Field4 = 4 [(gogoproto.nullable) = false]; + optional uint32 Field5 = 5 [(gogoproto.nullable) = false]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false]; + optional sint64 Field8 = 8 [(gogoproto.nullable) = false]; + optional fixed32 Field9 = 9 [(gogoproto.nullable) = false]; + optional sfixed32 Field10 = 10 [(gogoproto.nullable) = false]; + optional fixed64 Field11 = 11 [(gogoproto.nullable) = false]; + optional sfixed64 Field12 = 12 [(gogoproto.nullable) = false]; + optional bool Field13 = 13 [(gogoproto.nullable) = false]; + optional string Field14 = 14 [(gogoproto.nullable) = false]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinOptNative { + optional double Field1 = 1; + optional float Field2 = 2; + optional int32 Field3 = 3; + optional int64 Field4 = 4; + optional uint32 Field5 = 5; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional sint64 Field8 = 8; + optional fixed32 Field9 = 9; + optional sfixed32 Field10 = 10; + optional fixed64 Field11 = 11; + optional sfixed64 Field12 = 12; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NidRepNative { + repeated double Field1 = 1 [(gogoproto.nullable) = false]; + repeated float Field2 = 2 [(gogoproto.nullable) = false]; + repeated int32 Field3 = 3 [(gogoproto.nullable) = false]; + repeated int64 Field4 = 4 [(gogoproto.nullable) = false]; + repeated uint32 Field5 = 5 [(gogoproto.nullable) = false]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false]; + repeated sint64 Field8 = 8 [(gogoproto.nullable) = false]; + repeated fixed32 Field9 = 9 [(gogoproto.nullable) = false]; + repeated sfixed32 Field10 = 10 [(gogoproto.nullable) = false]; + repeated fixed64 Field11 = 11 [(gogoproto.nullable) = false]; + repeated sfixed64 Field12 = 12 [(gogoproto.nullable) = false]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false]; + repeated string Field14 = 14 [(gogoproto.nullable) = false]; + repeated bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinRepNative { + repeated double Field1 = 1; + repeated float Field2 = 2; + repeated int32 Field3 = 3; + repeated int64 Field4 = 4; + repeated uint32 Field5 = 5; + repeated uint64 Field6 = 6; + repeated sint32 Field7 = 7; + repeated sint64 Field8 = 8; + repeated fixed32 Field9 = 9; + repeated sfixed32 Field10 = 10; + repeated fixed64 Field11 = 11; + repeated sfixed64 Field12 = 12; + repeated bool Field13 = 13; + repeated string Field14 = 14; + repeated bytes Field15 = 15; +} + +message NidRepPackedNative { + repeated double Field1 = 1 [(gogoproto.nullable) = false, packed = true]; + repeated float Field2 = 2 [(gogoproto.nullable) = false, packed = true]; + repeated int32 Field3 = 3 [(gogoproto.nullable) = false, packed = true]; + repeated int64 Field4 = 4 [(gogoproto.nullable) = false, packed = true]; + repeated uint32 Field5 = 5 [(gogoproto.nullable) = false, packed = true]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false, packed = true]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false, packed = true]; + repeated sint64 Field8 = 8 [(gogoproto.nullable) = false, packed = true]; + repeated fixed32 Field9 = 9 [(gogoproto.nullable) = false, packed = true]; + repeated sfixed32 Field10 = 10 [(gogoproto.nullable) = false, packed = true]; + repeated fixed64 Field11 = 11 [(gogoproto.nullable) = false, packed = true]; + repeated sfixed64 Field12 = 12 [(gogoproto.nullable) = false, packed = true]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false, packed = true]; +} + +message NinRepPackedNative { + repeated double Field1 = 1 [packed = true]; + repeated float Field2 = 2 [packed = true]; + repeated int32 Field3 = 3 [packed = true]; + repeated int64 Field4 = 4 [packed = true]; + repeated uint32 Field5 = 5 [packed = true]; + repeated uint64 Field6 = 6 [packed = true]; + repeated sint32 Field7 = 7 [packed = true]; + repeated sint64 Field8 = 8 [packed = true]; + repeated fixed32 Field9 = 9 [packed = true]; + repeated sfixed32 Field10 = 10 [packed = true]; + repeated fixed64 Field11 = 11 [packed = true]; + repeated sfixed64 Field12 = 12 [packed = true]; + repeated bool Field13 = 13 [packed = true]; +} + +message NidOptStruct { + optional double Field1 = 1 [(gogoproto.nullable) = false]; + optional float Field2 = 2 [(gogoproto.nullable) = false]; + optional NidOptNative Field3 = 3 [(gogoproto.nullable) = false]; + optional NinOptNative Field4 = 4 [(gogoproto.nullable) = false]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false]; + optional NidOptNative Field8 = 8 [(gogoproto.nullable) = false]; + optional bool Field13 = 13 [(gogoproto.nullable) = false]; + optional string Field14 = 14 [(gogoproto.nullable) = false]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinOptStruct { + optional double Field1 = 1; + optional float Field2 = 2; + optional NidOptNative Field3 = 3; + optional NinOptNative Field4 = 4; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional NidOptNative Field8 = 8; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NidRepStruct { + repeated double Field1 = 1 [(gogoproto.nullable) = false]; + repeated float Field2 = 2 [(gogoproto.nullable) = false]; + repeated NidOptNative Field3 = 3 [(gogoproto.nullable) = false]; + repeated NinOptNative Field4 = 4 [(gogoproto.nullable) = false]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false]; + repeated NidOptNative Field8 = 8 [(gogoproto.nullable) = false]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false]; + repeated string Field14 = 14 [(gogoproto.nullable) = false]; + repeated bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinRepStruct { + repeated double Field1 = 1; + repeated float Field2 = 2; + repeated NidOptNative Field3 = 3; + repeated NinOptNative Field4 = 4; + repeated uint64 Field6 = 6; + repeated sint32 Field7 = 7; + repeated NidOptNative Field8 = 8; + repeated bool Field13 = 13; + repeated string Field14 = 14; + repeated bytes Field15 = 15; +} + +message NidEmbeddedStruct { + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NidOptNative Field200 = 200 [(gogoproto.nullable) = false]; + optional bool Field210 = 210 [(gogoproto.nullable) = false]; +} + +message NinEmbeddedStruct { + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NidOptNative Field200 = 200; + optional bool Field210 = 210; +} + +message NidNestedStruct { + optional NidOptStruct Field1 = 1 [(gogoproto.nullable) = false]; + repeated NidRepStruct Field2 = 2 [(gogoproto.nullable) = false]; +} + +message NinNestedStruct { + optional NinOptStruct Field1 = 1; + repeated NinRepStruct Field2 = 2; +} + +message NidOptCustom { + optional bytes Id = 1 [(gogoproto.customtype) = "Uuid", (gogoproto.nullable) = false]; + optional bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; +} + +message CustomDash { + optional bytes Value = 1 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom-dash-type.Bytes"]; +} + +message NinOptCustom { + optional bytes Id = 1 [(gogoproto.customtype) = "Uuid"]; + optional bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message NidRepCustom { + repeated bytes Id = 1 [(gogoproto.customtype) = "Uuid", (gogoproto.nullable) = false]; + repeated bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; +} + +message NinRepCustom { + repeated bytes Id = 1 [(gogoproto.customtype) = "Uuid"]; + repeated bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message NinOptNativeUnion { + option (gogoproto.onlyone) = true; + optional double Field1 = 1; + optional float Field2 = 2; + optional int32 Field3 = 3; + optional int64 Field4 = 4; + optional uint32 Field5 = 5; + optional uint64 Field6 = 6; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NinOptStructUnion { + option (gogoproto.onlyone) = true; + optional double Field1 = 1; + optional float Field2 = 2; + optional NidOptNative Field3 = 3; + optional NinOptNative Field4 = 4; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NinEmbeddedStructUnion { + option (gogoproto.onlyone) = true; + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NinOptNative Field200 = 200; + optional bool Field210 = 210; +} + +message NinNestedStructUnion { + option (gogoproto.onlyone) = true; + optional NinOptNativeUnion Field1 = 1; + optional NinOptStructUnion Field2 = 2; + optional NinEmbeddedStructUnion Field3 = 3; +} + +message Tree { + option (gogoproto.onlyone) = true; + optional OrBranch Or = 1; + optional AndBranch And = 2; + optional Leaf Leaf = 3; +} + +message OrBranch { + optional Tree Left = 1 [(gogoproto.nullable) = false]; + optional Tree Right = 2 [(gogoproto.nullable) = false]; +} + +message AndBranch { + optional Tree Left = 1 [(gogoproto.nullable) = false]; + optional Tree Right = 2 [(gogoproto.nullable) = false]; +} + +message Leaf { + optional int64 Value = 1 [(gogoproto.nullable) = false]; + optional string StrValue = 2 [(gogoproto.nullable) = false]; +} + +message DeepTree { + option (gogoproto.onlyone) = true; + optional ADeepBranch Down = 1; + optional AndDeepBranch And = 2; + optional DeepLeaf Leaf = 3; +} + +message ADeepBranch { + optional DeepTree Down = 2 [(gogoproto.nullable) = false]; +} + +message AndDeepBranch { + optional DeepTree Left = 1 [(gogoproto.nullable) = false]; + optional DeepTree Right = 2 [(gogoproto.nullable) = false]; +} + +message DeepLeaf { + optional Tree Tree = 1 [(gogoproto.nullable) = false]; +} + +message Nil { + +} + +enum TheTestEnum { + A = 0; + B = 1; + C = 2; +} + +message NidOptEnum { + optional TheTestEnum Field1 = 1 [(gogoproto.nullable) = false]; +} + +message NinOptEnum { + optional TheTestEnum Field1 = 1; +} + +message NidRepEnum { + repeated TheTestEnum Field1 = 1 [(gogoproto.nullable) = false]; +} + +message NinRepEnum { + repeated TheTestEnum Field1 = 1; +} + +message NinOptEnumDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional TheTestEnum Field1 = 1 [default=C]; +} + +enum AnotherTestEnum { + option (gogoproto.goproto_enum_prefix) = false; + D = 10; + E = 11; +} + +message AnotherNinOptEnum { + optional AnotherTestEnum Field1 = 1; +} + +message AnotherNinOptEnumDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional AnotherTestEnum Field1 = 1 [default=E]; +} + +message Timer { + optional sfixed64 Time1 = 1 [(gogoproto.nullable) = false]; + optional sfixed64 Time2 = 2 [(gogoproto.nullable) = false]; + optional bytes Data = 3 [(gogoproto.nullable) = false]; +} + +message MyExtendable { + option (gogoproto.face) = false; + optional int64 Field1 = 1; + extensions 100 to 199; +} + +extend MyExtendable { + optional double FieldA = 100; + optional NinOptNative FieldB = 101; + optional NinEmbeddedStruct FieldC = 102; +} + +message OtherExtenable { + option (gogoproto.face) = false; + optional int64 Field2 = 2; + extensions 14 to 16; + optional int64 Field13 = 13; + extensions 10 to 12; + optional MyExtendable M = 1; +} + +message NestedDefinition { + optional int64 Field1 = 1; + message NestedMessage { + optional fixed64 NestedField1 = 1; + optional NestedNestedMsg NNM = 2; + message NestedNestedMsg { + optional string NestedNestedField1 = 10; + } + } + enum NestedEnum { + TYPE_NESTED = 1; + } + optional NestedEnum EnumField = 2; + optional NestedMessage.NestedNestedMsg NNM = 3; + optional NestedMessage NM = 4; +} + +message NestedScope { + optional NestedDefinition.NestedMessage.NestedNestedMsg A = 1; + optional NestedDefinition.NestedEnum B = 2; + optional NestedDefinition.NestedMessage C = 3; +} + +message NinOptNativeDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional double Field1 = 1 [default = 1234.1234]; + optional float Field2 = 2 [default = 1234.1234]; + optional int32 Field3 = 3 [default = 1234]; + optional int64 Field4 = 4 [default = 1234]; + optional uint32 Field5 = 5 [default = 1234]; + optional uint64 Field6 = 6 [default = 1234]; + optional sint32 Field7 = 7 [default = 1234]; + optional sint64 Field8 = 8 [default = 1234]; + optional fixed32 Field9 = 9 [default = 1234]; + optional sfixed32 Field10 = 10 [default = 1234]; + optional fixed64 Field11 = 11 [default = 1234]; + optional sfixed64 Field12 = 12 [default = 1234]; + optional bool Field13 = 13 [default = true]; + optional string Field14 = 14 [default = "1234"]; + optional bytes Field15 = 15; +} + +message CustomContainer { + optional NidOptCustom CustomStruct = 1 [(gogoproto.nullable) = false]; +} + +message CustomNameNidOptNative { + optional double Field1 = 1 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldB"]; + optional int32 Field3 = 3 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldC"]; + optional int64 Field4 = 4 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldD"]; + optional uint32 Field5 = 5 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldE"]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldF"]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldG"]; + optional sint64 Field8 = 8 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldH"]; + optional fixed32 Field9 = 9 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldI"]; + optional sfixed32 Field10 = 10 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldJ"]; + optional fixed64 Field11 = 11 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldK"]; + optional sfixed64 Field12 = 12 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldL"]; + optional bool Field13 = 13 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldM"]; + optional string Field14 = 14 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldN"]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinOptNative { + optional double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + optional int32 Field3 = 3 [(gogoproto.customname) = "FieldC"]; + optional int64 Field4 = 4 [(gogoproto.customname) = "FieldD"]; + optional uint32 Field5 = 5 [(gogoproto.customname) = "FieldE"]; + optional uint64 Field6 = 6 [(gogoproto.customname) = "FieldF"]; + optional sint32 Field7 = 7 [(gogoproto.customname) = "FieldG"]; + optional sint64 Field8 = 8 [(gogoproto.customname) = "FieldH"]; + optional fixed32 Field9 = 9 [(gogoproto.customname) = "FieldI"]; + optional sfixed32 Field10 = 10 [(gogoproto.customname) = "FieldJ"]; + optional fixed64 Field11 = 11 [(gogoproto.customname) = "FieldK"]; + optional sfixed64 Field12 = 12 [(gogoproto.customname) = "FielL"]; + optional bool Field13 = 13 [(gogoproto.customname) = "FieldM"]; + optional string Field14 = 14 [(gogoproto.customname) = "FieldN"]; + optional bytes Field15 = 15 [(gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinRepNative { + repeated double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + repeated float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + repeated int32 Field3 = 3 [(gogoproto.customname) = "FieldC"]; + repeated int64 Field4 = 4 [(gogoproto.customname) = "FieldD"]; + repeated uint32 Field5 = 5 [(gogoproto.customname) = "FieldE"]; + repeated uint64 Field6 = 6 [(gogoproto.customname) = "FieldF"]; + repeated sint32 Field7 = 7 [(gogoproto.customname) = "FieldG"]; + repeated sint64 Field8 = 8 [(gogoproto.customname) = "FieldH"]; + repeated fixed32 Field9 = 9 [(gogoproto.customname) = "FieldI"]; + repeated sfixed32 Field10 = 10 [(gogoproto.customname) = "FieldJ"]; + repeated fixed64 Field11 = 11 [(gogoproto.customname) = "FieldK"]; + repeated sfixed64 Field12 = 12 [(gogoproto.customname) = "FieldL"]; + repeated bool Field13 = 13 [(gogoproto.customname) = "FieldM"]; + repeated string Field14 = 14 [(gogoproto.customname) = "FieldN"]; + repeated bytes Field15 = 15 [(gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinStruct { + optional double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + optional NidOptNative Field3 = 3 [(gogoproto.customname) = "FieldC"]; + repeated NinOptNative Field4 = 4 [(gogoproto.customname) = "FieldD"]; + optional uint64 Field6 = 6 [(gogoproto.customname) = "FieldE"]; + optional sint32 Field7 = 7 [(gogoproto.customname) = "FieldF"]; + optional NidOptNative Field8 = 8 [(gogoproto.customname) = "FieldG"]; + optional bool Field13 = 13 [(gogoproto.customname) = "FieldH"]; + optional string Field14 = 14 [(gogoproto.customname) = "FieldI"]; + optional bytes Field15 = 15 [(gogoproto.customname) = "FieldJ"]; +} + +message CustomNameCustomType { + optional bytes Id = 1 [(gogoproto.customname) = "FieldA", (gogoproto.customtype) = "Uuid"]; + optional bytes Value = 2 [(gogoproto.customname) = "FieldB", (gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; + repeated bytes Ids = 3 [(gogoproto.customname) = "FieldC", (gogoproto.customtype) = "Uuid"]; + repeated bytes Values = 4 [(gogoproto.customname) = "FieldD", (gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message CustomNameNinEmbeddedStructUnion { + option (gogoproto.onlyone) = true; + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NinOptNative Field200 = 200 [(gogoproto.customname) = "FieldA"]; + optional bool Field210 = 210 [(gogoproto.customname) = "FieldB"]; +} + +message CustomNameEnum { + optional TheTestEnum Field1 = 1 [(gogoproto.customname) = "FieldA"]; + repeated TheTestEnum Field2 = 2 [(gogoproto.customname) = "FieldB"]; +} + +message NoExtensionsMap { + option (gogoproto.face) = false; + option (gogoproto.goproto_extensions_map) = false; + optional int64 Field1 = 1; + extensions 100 to 199; +} + +extend NoExtensionsMap { + optional double FieldA1 = 100; + optional NinOptNative FieldB1 = 101; + optional NinEmbeddedStruct FieldC1 = 102; +} + +message Unrecognized { + option (gogoproto.goproto_unrecognized) = false; + optional string Field1 = 1; +} + +message UnrecognizedWithInner { + message Inner { + option (gogoproto.goproto_unrecognized) = false; + optional uint32 Field1 = 1; + } + + repeated Inner embedded = 1; + optional string Field2 = 2; +} + +message UnrecognizedWithEmbed { + message Embedded { + option (gogoproto.goproto_unrecognized) = false; + optional uint32 Field1 = 1; + } + + optional Embedded embedded = 1 [(gogoproto.embed) = true, (gogoproto.nullable) = false]; + optional string Field2 = 2; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both/thetestpb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both/thetestpb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..5f4def8d772d5cc72360187a773c3c724114ebdd --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both/thetestpb_test.go @@ -0,0 +1,14647 @@ +// Code generated by protoc-gen-gogo. +// source: combos/both/thetest.proto +// DO NOT EDIT! + +/* +Package test is a generated protocol buffer package. + +It is generated from these files: + combos/both/thetest.proto + +It has these top-level messages: + NidOptNative + NinOptNative + NidRepNative + NinRepNative + NidRepPackedNative + NinRepPackedNative + NidOptStruct + NinOptStruct + NidRepStruct + NinRepStruct + NidEmbeddedStruct + NinEmbeddedStruct + NidNestedStruct + NinNestedStruct + NidOptCustom + CustomDash + NinOptCustom + NidRepCustom + NinRepCustom + NinOptNativeUnion + NinOptStructUnion + NinEmbeddedStructUnion + NinNestedStructUnion + Tree + OrBranch + AndBranch + Leaf + DeepTree + ADeepBranch + AndDeepBranch + DeepLeaf + Nil + NidOptEnum + NinOptEnum + NidRepEnum + NinRepEnum + NinOptEnumDefault + AnotherNinOptEnum + AnotherNinOptEnumDefault + Timer + MyExtendable + OtherExtenable + NestedDefinition + NestedScope + NinOptNativeDefault + CustomContainer + CustomNameNidOptNative + CustomNameNinOptNative + CustomNameNinRepNative + CustomNameNinStruct + CustomNameCustomType + CustomNameNinEmbeddedStructUnion + CustomNameEnum + NoExtensionsMap + Unrecognized + UnrecognizedWithInner + UnrecognizedWithEmbed +*/ +package test + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestNidOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidOptNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepPackedNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepPackedNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepPackedNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepPackedNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepPackedNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepPackedNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepPackedNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepPackedNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepPackedNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepPackedNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepPackedNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepPackedNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepPackedNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepPackedNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidOptStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidOptStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidEmbeddedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidEmbeddedStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidEmbeddedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidEmbeddedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidEmbeddedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidEmbeddedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidEmbeddedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinEmbeddedStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinEmbeddedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinEmbeddedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinEmbeddedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidNestedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidNestedStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidNestedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidNestedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidNestedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidNestedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidNestedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinNestedStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinNestedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinNestedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinNestedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidOptCustomMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidOptCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomDashProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomDashMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomDashProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomDash, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomDash(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomDashProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomDash(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomDash{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptCustomMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepCustomMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepCustomMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptNativeUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptNativeUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNativeUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNativeUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptStructUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinEmbeddedStructUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinEmbeddedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinEmbeddedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinNestedStructUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinNestedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinNestedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinNestedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinNestedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestTreeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestTreeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkTreeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Tree, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkTreeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTree(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Tree{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestOrBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestOrBranchMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkOrBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OrBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedOrBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkOrBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOrBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &OrBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAndBranchMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAndBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAndBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAndBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AndBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestLeafProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestLeafMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkLeafProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Leaf, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkLeafProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLeaf(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Leaf{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepTreeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestDeepTreeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkDeepTreeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepTree, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedDeepTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkDeepTreeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepTree(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &DeepTree{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestADeepBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestADeepBranchMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkADeepBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*ADeepBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedADeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkADeepBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedADeepBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &ADeepBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndDeepBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAndDeepBranchMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAndDeepBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndDeepBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAndDeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAndDeepBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndDeepBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AndDeepBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepLeafProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestDeepLeafMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkDeepLeafProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepLeaf, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedDeepLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkDeepLeafProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepLeaf(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &DeepLeaf{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNilProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNilMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNilProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nil, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNil(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNilProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNil(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Nil{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidOptEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptEnumDefaultMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptEnumDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnumDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptEnumDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnumDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptEnumDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAnotherNinOptEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAnotherNinOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAnotherNinOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AnotherNinOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAnotherNinOptEnumDefaultMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAnotherNinOptEnumDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnumDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAnotherNinOptEnumDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnumDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AnotherNinOptEnumDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestTimerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestTimerMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkTimerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Timer, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedTimer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkTimerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTimer(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Timer{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMyExtendableProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestMyExtendableMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkMyExtendableProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MyExtendable, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMyExtendable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMyExtendableProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMyExtendable(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &MyExtendable{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestOtherExtenableProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestOtherExtenableMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkOtherExtenableProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OtherExtenable, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedOtherExtenable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkOtherExtenableProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOtherExtenable(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &OtherExtenable{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinitionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedDefinitionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedDefinitionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinitionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessageProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedDefinition_NestedMessageMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedDefinition_NestedMessageProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinition_NestedMessageProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition_NestedMessage{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedScopeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedScopeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedScopeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedScope, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedScope(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedScopeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedScope(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedScope{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptNativeDefaultMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptNativeDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNativeDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNativeDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomContainerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomContainerMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomContainerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomContainer, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomContainer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomContainerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomContainer(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomContainer{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNidOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNidOptNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNidOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNidOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNidOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNidOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNidOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNinOptNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNinOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNinRepNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNinRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNinStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNinStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameCustomTypeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameCustomTypeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameCustomTypeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameCustomType, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameCustomType(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameCustomTypeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameCustomType(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameCustomType{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinEmbeddedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNinEmbeddedStructUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNinEmbeddedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinEmbeddedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinEmbeddedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNoExtensionsMapProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNoExtensionsMapMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNoExtensionsMapProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NoExtensionsMap, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNoExtensionsMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNoExtensionsMapProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNoExtensionsMap(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NoExtensionsMap{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Unrecognized, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognized(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognized(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Unrecognized{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInnerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedWithInnerMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedWithInnerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithInnerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithInner{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInner_InnerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedWithInner_InnerMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedWithInner_InnerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner_Inner, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithInner_InnerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner_Inner(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithInner_Inner{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedWithEmbedMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedWithEmbedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithEmbedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithEmbed{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbed_EmbeddedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed_Embedded, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithEmbed_Embedded{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepPackedNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepPackedNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidEmbeddedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinEmbeddedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidNestedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinNestedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomDashJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinEmbeddedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinNestedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTreeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOrBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAndBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestLeafJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestDeepTreeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestADeepBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAndDeepBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestDeepLeafJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNilJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptEnumDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAnotherNinOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAnotherNinOptEnumDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTimerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMyExtendableJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOtherExtenableJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinitionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinition_NestedMessageJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedScopeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomContainerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNidOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameCustomTypeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNoExtensionsMapJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithInnerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithInner_InnerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithEmbedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithEmbed_EmbeddedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepPackedNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepPackedNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepPackedNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepPackedNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidEmbeddedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidEmbeddedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidNestedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidNestedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomDashProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomDashProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTreeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTreeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOrBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOrBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestLeafProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestLeafProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepTreeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepTreeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestADeepBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestADeepBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndDeepBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndDeepBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepLeafProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepLeafProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNilProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNilProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTimerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTimerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMyExtendableProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMyExtendableProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOtherExtenableProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOtherExtenableProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinitionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinitionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessageProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessageProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedScopeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedScopeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomContainerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomContainerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNidOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNidOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameCustomTypeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameCustomTypeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinEmbeddedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinEmbeddedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNoExtensionsMapProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNoExtensionsMapProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInnerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInnerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInner_InnerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInner_InnerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestThetestDescription(t *testing.T) { + ThetestDescription() +} +func TestNidOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepPackedNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepPackedNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidEmbeddedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinEmbeddedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidNestedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinNestedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomDashVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinNestedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTreeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOrBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAndBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestLeafVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestDeepTreeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestADeepBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAndDeepBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestDeepLeafVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNilVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptEnumDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAnotherNinOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAnotherNinOptEnumDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTimerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMyExtendableVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOtherExtenableVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinitionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinition_NestedMessageVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedScopeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomContainerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNidOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameCustomTypeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNoExtensionsMapVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithInnerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithInner_InnerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithEmbedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithEmbed_EmbeddedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepPackedNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepPackedNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidEmbeddedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidNestedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinNestedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomDashFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptNativeUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinNestedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestTreeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestOrBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAndBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestLeafFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestDeepTreeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestADeepBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAndDeepBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestDeepLeafFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNilFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAnotherNinOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestTimerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinitionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinition_NestedMessageFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedScopeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomContainerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNidOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameCustomTypeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithInnerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithInner_InnerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithEmbedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithEmbed_EmbeddedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepPackedNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepPackedNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidEmbeddedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinEmbeddedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidNestedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinNestedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomDashGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinEmbeddedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinNestedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTreeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOrBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAndBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestLeafGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestDeepTreeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestADeepBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAndDeepBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestDeepLeafGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNilGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptEnumDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAnotherNinOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAnotherNinOptEnumDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTimerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMyExtendableGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOtherExtenableGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinitionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinition_NestedMessageGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedScopeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomContainerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNidOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameCustomTypeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinEmbeddedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNoExtensionsMapGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithInnerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithInner_InnerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithEmbedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithEmbed_EmbeddedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepPackedNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepPackedNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepPackedNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepPackedNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepPackedNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepPackedNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidEmbeddedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidEmbeddedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidEmbeddedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinEmbeddedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidNestedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidNestedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidNestedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinNestedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomDashSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomDashSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomDash, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomDash(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNativeUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinEmbeddedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinNestedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinNestedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestTreeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkTreeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Tree, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestOrBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkOrBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OrBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedOrBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAndBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAndBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestLeafSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkLeafSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Leaf, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepTreeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkDeepTreeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepTree, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedDeepTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestADeepBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkADeepBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*ADeepBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedADeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndDeepBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAndDeepBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndDeepBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAndDeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepLeafSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkDeepLeafSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepLeaf, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedDeepLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNilSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNilSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nil, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNil(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptEnumDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnumDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAnotherNinOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAnotherNinOptEnumDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnumDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestTimerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkTimerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Timer, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedTimer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMyExtendableSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMyExtendableSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MyExtendable, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMyExtendable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestOtherExtenableSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkOtherExtenableSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OtherExtenable, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedOtherExtenable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinitionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinitionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessageSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinition_NestedMessageSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedScopeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedScopeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedScope, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedScope(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNativeDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomContainerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomContainerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomContainer, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomContainer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNidOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNidOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNidOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameCustomTypeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameCustomTypeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameCustomType, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameCustomType(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinEmbeddedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinEmbeddedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinEmbeddedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNoExtensionsMapSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNoExtensionsMapSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NoExtensionsMap, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNoExtensionsMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Unrecognized, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognized(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInnerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithInnerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInner_InnerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithInner_InnerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner_Inner, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithEmbedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbed_EmbeddedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed_Embedded, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepPackedNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepPackedNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidEmbeddedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinEmbeddedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidNestedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinNestedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomDashStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinEmbeddedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinNestedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTreeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOrBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAndBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestLeafStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestDeepTreeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestADeepBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAndDeepBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestDeepLeafStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNilStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptEnumDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAnotherNinOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAnotherNinOptEnumDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTimerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestMyExtendableStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOtherExtenableStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinitionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinition_NestedMessageStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedScopeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomContainerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNidOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameCustomTypeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinEmbeddedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNoExtensionsMapStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithInnerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithInner_InnerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithEmbedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithEmbed_EmbeddedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, true) + v := p.GetValue() + msg := &NinOptNativeUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinOptStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, true) + v := p.GetValue() + msg := &NinOptStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + v := p.GetValue() + msg := &NinEmbeddedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinNestedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, true) + v := p.GetValue() + msg := &NinNestedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestTreeOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, true) + v := p.GetValue() + msg := &Tree{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestDeepTreeOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, true) + v := p.GetValue() + msg := &DeepTree{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + v := p.GetValue() + msg := &CustomNameNinEmbeddedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both/uuid.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both/uuid.go new file mode 100644 index 0000000000000000000000000000000000000000..4c071114bcce237893cd1f0fa4baca9d8663b571 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both/uuid.go @@ -0,0 +1,122 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 test + +import ( + "bytes" + "encoding/json" +) + +func PutLittleEndianUint64(b []byte, offset int, v uint64) { + b[offset] = byte(v) + b[offset+1] = byte(v >> 8) + b[offset+2] = byte(v >> 16) + b[offset+3] = byte(v >> 24) + b[offset+4] = byte(v >> 32) + b[offset+5] = byte(v >> 40) + b[offset+6] = byte(v >> 48) + b[offset+7] = byte(v >> 56) +} + +type Uuid []byte + +func (uuid Uuid) Marshal() ([]byte, error) { + if len(uuid) == 0 { + return nil, nil + } + return []byte(uuid), nil +} + +func (uuid Uuid) MarshalTo(data []byte) (n int, err error) { + if len(uuid) == 0 { + return 0, nil + } + copy(data, uuid) + return 16, nil +} + +func (uuid *Uuid) Unmarshal(data []byte) error { + if len(data) == 0 { + uuid = nil + return nil + } + id := Uuid(make([]byte, 16)) + copy(id, data) + *uuid = id + return nil +} + +func (uuid *Uuid) Size() int { + if uuid == nil { + return 0 + } + if len(*uuid) == 0 { + return 0 + } + return 16 +} + +func (uuid Uuid) MarshalJSON() ([]byte, error) { + return json.Marshal([]byte(uuid)) +} + +func (uuid *Uuid) UnmarshalJSON(data []byte) error { + v := new([]byte) + err := json.Unmarshal(data, v) + if err != nil { + return err + } + return uuid.Unmarshal(*v) +} + +func (uuid Uuid) Equal(other Uuid) bool { + return bytes.Equal(uuid[0:], other[0:]) +} + +type int63 interface { + Int63() int64 +} + +func NewPopulatedUuid(r int63) *Uuid { + u := RandV4(r) + return &u +} + +func RandV4(r int63) Uuid { + uuid := make(Uuid, 16) + uuid.RandV4(r) + return uuid +} + +func (uuid Uuid) RandV4(r int63) { + PutLittleEndianUint64(uuid, 0, uint64(r.Int63())) + PutLittleEndianUint64(uuid, 8, uint64(r.Int63())) + uuid[6] = (uuid[6] & 0xf) | 0x40 + uuid[8] = (uuid[8] & 0x3f) | 0x80 +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/marshaler/bug_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/marshaler/bug_test.go new file mode 100644 index 0000000000000000000000000000000000000000..264d3982327d7276cc42c9314074f391dde60dfa --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/marshaler/bug_test.go @@ -0,0 +1,186 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 test + +import ( + "fmt" + "math" + "testing" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +) + +//http://code.google.com/p/goprotobuf/issues/detail?id=39 +func TestBugUint32VarintSize(t *testing.T) { + temp := uint32(math.MaxUint32) + n := &NinOptNative{} + n.Field5 = &temp + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != 6 { + t.Fatalf("data should be length 6, but its %#v", data) + } +} + +func TestBugZeroLengthSliceSize(t *testing.T) { + n := &NinRepPackedNative{ + Field8: []int64{}, + } + size := n.Size() + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != size { + t.Fatalf("expected %v, but got %v", len(data), size) + } +} + +//http://code.google.com/p/goprotobuf/issues/detail?id=40 +func TestBugPackedProtoSize(t *testing.T) { + n := &NinRepPackedNative{ + Field4: []int64{172960727389894724, 2360337516664475010, 860833876131988189, 9068073014890763245, 7794843386260381831, 4023536436053141786, 8992311247496919020, 4330096163611305776, 4490411416244976467, 7873947349172707443, 2754969595834279669, 1360667855926938684, 4771480785172657389, 4875578924966668055, 8070579869808877481, 9128179594766551001, 4630419407064527516, 863844540220372892, 8208727650143073487, 7086117356301045838, 7779695211931506151, 5493835345187563535, 9119767633370806007, 9054342025895349248, 1887303228838508438, 7624573031734528281, 1874668389749611225, 3517684643468970593, 6677697606628877758, 7293473953189936168, 444475066704085538, 8594971141363049302, 1146643249094989673, 733393306232853371, 7721178528893916886, 7784452000911004429, 6436373110242711440, 6897422461738321237, 8772249155667732778, 6211871464311393541, 3061903718310406883, 7845488913176136641, 8342255034663902574, 3443058984649725748, 8410801047334832902, 7496541071517841153, 4305416923521577765, 7814967600020476457, 8671843803465481186, 3490266370361096855, 1447425664719091336, 653218597262334239, 8306243902880091940, 7851896059762409081, 5936760560798954978, 5755724498441478025, 7022701569985035966, 3707709584811468220, 529069456924666920, 7986469043681522462, 3092513330689518836, 5103541550470476202, 3577384161242626406, 3733428084624703294, 8388690542440473117, 3262468785346149388, 8788358556558007570, 5476276940198542020, 7277903243119461239, 5065861426928605020, 7533460976202697734, 1749213838654236956, 557497603941617931, 5496307611456481108, 6444547750062831720, 6992758776744205596, 7356719693428537399, 2896328872476734507, 381447079530132038, 598300737753233118, 3687980626612697715, 7240924191084283349, 8172414415307971170, 4847024388701257185, 2081764168600256551, 3394217778539123488, 6244660626429310923, 8301712215675381614, 5360615125359461174, 8410140945829785773, 3152963269026381373, 6197275282781459633, 4419829061407546410, 6262035523070047537, 2837207483933463885, 2158105736666826128, 8150764172235490711}, + Field7: []int32{249451845, 1409974015, 393609128, 435232428, 1817529040, 91769006, 861170933, 1556185603, 1568580279, 1236375273, 512276621, 693633711, 967580535, 1950715977, 853431462, 1362390253, 159591204, 111900629, 322985263, 279671129, 1592548430, 465651370, 733849989, 1172059400, 1574824441, 263541092, 1271612397, 1520584358, 467078791, 117698716, 1098255064, 2054264846, 1766452305, 1267576395, 1557505617, 1187833560, 956187431, 1970977586, 1160235159, 1610259028, 489585797, 459139078, 566263183, 954319278, 1545018565, 1753946743, 948214318, 422878159, 883926576, 1424009347, 824732372, 1290433180, 80297942, 417294230, 1402647904, 2078392782, 220505045, 787368129, 463781454, 293083578, 808156928, 293976361}, + Field9: []uint32{0xaa4976e8, 0x3da8cc4c, 0x8c470d83, 0x344d964e, 0x5b90925, 0xa4c4d34e, 0x666eff19, 0xc238e552, 0x9be53bb6, 0x56364245, 0x33ee079d, 0x96bf0ede, 0x7941b74f, 0xdb07cb47, 0x6d76d827, 0x9b211d5d, 0x2798adb6, 0xe48b0c3b, 0x87061b21, 0x48f4e4d2, 0x3e5d5c12, 0x5ee91288, 0x336d4f35, 0xe1d44941, 0xc065548d, 0x2953d73f, 0x873af451, 0xfc769db, 0x9f1bf8da, 0x9baafdfc, 0xf1d3d770, 0x5bb5d2b4, 0xc2c67c48, 0x6845c4c1, 0xa48f32b0, 0xbb04bb70, 0xa5b1ca36, 0x8d98356a, 0x2171f654, 0x5ae279b0, 0x6c4a3d6b, 0x4fff5468, 0xcf9bf851, 0x68513614, 0xdbecd9b0, 0x9553ed3c, 0xa494a736, 0x42205438, 0xbf8e5caa, 0xd3283c6, 0x76d20788, 0x9179826f, 0x96b24f85, 0xbc2eacf4, 0xe4afae0b, 0x4bca85cb, 0x35e63b5b, 0xd7ccee0c, 0x2b506bb9, 0xe78e9f44, 0x9ad232f1, 0x99a37335, 0xa5d6ffc8}, + Field11: []uint64{0x53c01ebc, 0x4fb85ba6, 0x8805eea1, 0xb20ec896, 0x93b63410, 0xec7c9492, 0x50765a28, 0x19592106, 0x2ecc59b3, 0x39cd474f, 0xe4c9e47, 0x444f48c5, 0xe7731d32, 0xf3f43975, 0x603caedd, 0xbb05a1af, 0xa808e34e, 0x88580b07, 0x4c96bbd1, 0x730b4ab9, 0xed126e2b, 0x6db48205, 0x154ba1b9, 0xc26bfb6a, 0x389aa052, 0x869d966c, 0x7c86b366, 0xcc8edbcd, 0xfa8d6dad, 0xcf5857d9, 0x2d9cda0f, 0x1218a0b8, 0x41bf997, 0xf0ca65ac, 0xa610d4b9, 0x8d362e28, 0xb7212d87, 0x8e0fe109, 0xbee041d9, 0x759be2f6, 0x35fef4f3, 0xaeacdb71, 0x10888852, 0xf4e28117, 0xe2a14812, 0x73b748dc, 0xd1c3c6b2, 0xfef41bf0, 0xc9b43b62, 0x810e4faa, 0xcaa41c06, 0x1893fe0d, 0xedc7c850, 0xd12b9eaa, 0x467ee1a9, 0xbe84756b, 0xda7b1680, 0xdc069ffe, 0xf1e7e9f9, 0xb3d95370, 0xa92b77df, 0x5693ac41, 0xd04b7287, 0x27aebf15, 0x837b316e, 0x4dbe2263, 0xbab70c67, 0x547dab21, 0x3c346c1f, 0xb8ef0e4e, 0xfe2d03ce, 0xe1d75955, 0xfec1306, 0xba35c23e, 0xb784ed04, 0x2a4e33aa, 0x7e19d09a, 0x3827c1fe, 0xf3a51561, 0xef765e2b, 0xb044256c, 0x62b322be, 0xf34d56be, 0xeb71b369, 0xffe1294f, 0x237fe8d0, 0x77a1473b, 0x239e1196, 0xdd19bf3d, 0x82c91fe1, 0x95361c57, 0xffea3f1b, 0x1a094c84}, + Field12: []int64{8308420747267165049, 3664160795077875961, 7868970059161834817, 7237335984251173739, 5254748003907196506, 3362259627111837480, 430460752854552122, 5119635556501066533, 1277716037866233522, 9185775384759813768, 833932430882717888, 7986528304451297640, 6792233378368656337, 2074207091120609721, 1788723326198279432, 7756514594746453657, 2283775964901597324, 3061497730110517191, 7733947890656120277, 626967303632386244, 7822928600388582821, 3489658753000061230, 168869995163005961, 248814782163480763, 477885608911386247, 4198422415674133867, 3379354662797976109, 9925112544736939, 1486335136459138480, 4561560414032850671, 1010864164014091267, 186722821683803084, 5106357936724819318, 1298160820191228988, 4675403242419953145, 7130634540106489752, 7101280006672440929, 7176058292431955718, 9109875054097770321, 6810974877085322872, 4736707874303993641, 8993135362721382187, 6857881554990254283, 3704748883307461680, 1099360832887634994, 5207691918707192633, 5984721695043995243}, + } + size := proto.Size(n) + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != size { + t.Fatalf("expected %v, but got %v diff is %v", len(data), size, len(data)-size) + } +} + +func testSize(m interface { + proto.Message + Size() int +}, desc string, expected int) ([]byte, error) { + data, err := proto.Marshal(m) + if err != nil { + return nil, err + } + protoSize := proto.Size(m) + mSize := m.Size() + lenData := len(data) + if protoSize != mSize || protoSize != lenData || mSize != lenData { + return nil, fmt.Errorf("%s proto.Size(m){%d} != m.Size(){%d} != len(data){%d}", desc, protoSize, mSize, lenData) + } + if got := protoSize; got != expected { + return nil, fmt.Errorf("%s proto.Size(m) got %d expected %d", desc, got, expected) + } + if got := mSize; got != expected { + return nil, fmt.Errorf("%s m.Size() got %d expected %d", desc, got, expected) + } + if got := lenData; got != expected { + return nil, fmt.Errorf("%s len(data) got %d expected %d", desc, got, expected) + } + return data, nil +} + +func TestInt32Int64Compatibility(t *testing.T) { + + //test nullable int32 and int64 + + data1, err := testSize(&NinOptNative{ + Field3: proto.Int32(-1), + }, "nullable", 11) + if err != nil { + t.Error(err) + } + //change marshaled data1 to unmarshal into 4th field which is an int64 + data1[0] = uint8(uint32(4 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + u1 := &NinOptNative{} + if err := proto.Unmarshal(data1, u1); err != nil { + t.Error(err) + } + if !u1.Equal(&NinOptNative{ + Field4: proto.Int64(-1), + }) { + t.Error("nullable unmarshaled int32 is not the same int64") + } + + //test non-nullable int32 and int64 + + data2, err := testSize(&NidOptNative{ + Field3: -1, + }, "non nullable", 67) + if err != nil { + t.Error(err) + } + //change marshaled data2 to unmarshal into 4th field which is an int64 + field3 := uint8(uint32(3 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + field4 := uint8(uint32(4 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + for i, c := range data2 { + if c == field4 { + data2[i] = field3 + } else if c == field3 { + data2[i] = field4 + } + } + u2 := &NidOptNative{} + if err := proto.Unmarshal(data2, u2); err != nil { + t.Error(err) + } + if !u2.Equal(&NidOptNative{ + Field4: -1, + }) { + t.Error("non nullable unmarshaled int32 is not the same int64") + } + + //test packed repeated int32 and int64 + + m4 := &NinRepPackedNative{ + Field3: []int32{-1}, + } + data4, err := testSize(m4, "packed", 12) + if err != nil { + t.Error(err) + } + u4 := &NinRepPackedNative{} + if err := proto.Unmarshal(data4, u4); err != nil { + t.Error(err) + } + if err := u4.VerboseEqual(m4); err != nil { + t.Fatalf("%#v", u4) + } + + //test repeated int32 and int64 + + if _, err := testSize(&NinRepNative{ + Field3: []int32{-1}, + }, "repeated", 11); err != nil { + t.Error(err) + } + + t.Logf("tested all") +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/marshaler/thetest.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/marshaler/thetest.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..7ab23571e027795ae6f9e2c92ba76383d5f8a0ff --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/marshaler/thetest.pb.go @@ -0,0 +1,25915 @@ +// Code generated by protoc-gen-gogo. +// source: combos/marshaler/thetest.proto +// DO NOT EDIT! + +/* + Package test is a generated protocol buffer package. + + It is generated from these files: + combos/marshaler/thetest.proto + + It has these top-level messages: + NidOptNative + NinOptNative + NidRepNative + NinRepNative + NidRepPackedNative + NinRepPackedNative + NidOptStruct + NinOptStruct + NidRepStruct + NinRepStruct + NidEmbeddedStruct + NinEmbeddedStruct + NidNestedStruct + NinNestedStruct + NidOptCustom + CustomDash + NinOptCustom + NidRepCustom + NinRepCustom + NinOptNativeUnion + NinOptStructUnion + NinEmbeddedStructUnion + NinNestedStructUnion + Tree + OrBranch + AndBranch + Leaf + DeepTree + ADeepBranch + AndDeepBranch + DeepLeaf + Nil + NidOptEnum + NinOptEnum + NidRepEnum + NinRepEnum + NinOptEnumDefault + AnotherNinOptEnum + AnotherNinOptEnumDefault + Timer + MyExtendable + OtherExtenable + NestedDefinition + NestedScope + NinOptNativeDefault + CustomContainer + CustomNameNidOptNative + CustomNameNinOptNative + CustomNameNinRepNative + CustomNameNinStruct + CustomNameCustomType + CustomNameNinEmbeddedStructUnion + CustomNameEnum + NoExtensionsMap + Unrecognized + UnrecognizedWithInner + UnrecognizedWithEmbed +*/ +package test + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_custom "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom" +import github_com_gogo_protobuf_test_custom_dash_type "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom-dash-type" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type TheTestEnum int32 + +const ( + A TheTestEnum = 0 + B TheTestEnum = 1 + C TheTestEnum = 2 +) + +var TheTestEnum_name = map[int32]string{ + 0: "A", + 1: "B", + 2: "C", +} +var TheTestEnum_value = map[string]int32{ + "A": 0, + "B": 1, + "C": 2, +} + +func (x TheTestEnum) Enum() *TheTestEnum { + p := new(TheTestEnum) + *p = x + return p +} +func (x TheTestEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(TheTestEnum_name, int32(x)) +} +func (x *TheTestEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(TheTestEnum_value, data, "TheTestEnum") + if err != nil { + return err + } + *x = TheTestEnum(value) + return nil +} + +type AnotherTestEnum int32 + +const ( + D AnotherTestEnum = 10 + E AnotherTestEnum = 11 +) + +var AnotherTestEnum_name = map[int32]string{ + 10: "D", + 11: "E", +} +var AnotherTestEnum_value = map[string]int32{ + "D": 10, + "E": 11, +} + +func (x AnotherTestEnum) Enum() *AnotherTestEnum { + p := new(AnotherTestEnum) + *p = x + return p +} +func (x AnotherTestEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(AnotherTestEnum_name, int32(x)) +} +func (x *AnotherTestEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(AnotherTestEnum_value, data, "AnotherTestEnum") + if err != nil { + return err + } + *x = AnotherTestEnum(value) + return nil +} + +type NestedDefinition_NestedEnum int32 + +const ( + TYPE_NESTED NestedDefinition_NestedEnum = 1 +) + +var NestedDefinition_NestedEnum_name = map[int32]string{ + 1: "TYPE_NESTED", +} +var NestedDefinition_NestedEnum_value = map[string]int32{ + "TYPE_NESTED": 1, +} + +func (x NestedDefinition_NestedEnum) Enum() *NestedDefinition_NestedEnum { + p := new(NestedDefinition_NestedEnum) + *p = x + return p +} +func (x NestedDefinition_NestedEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(NestedDefinition_NestedEnum_name, int32(x)) +} +func (x *NestedDefinition_NestedEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(NestedDefinition_NestedEnum_value, data, "NestedDefinition_NestedEnum") + if err != nil { + return err + } + *x = NestedDefinition_NestedEnum(value) + return nil +} + +type NidOptNative struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + Field3 int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3"` + Field4 int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4"` + Field5 uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5"` + Field6 uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8"` + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9"` + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10"` + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11"` + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12"` + Field13 bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + Field14 string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptNative) Reset() { *m = NidOptNative{} } +func (*NidOptNative) ProtoMessage() {} + +type NinOptNative struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"` + Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"` + Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"` + Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"` + Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNative) Reset() { *m = NinOptNative{} } +func (*NinOptNative) ProtoMessage() {} + +type NidRepNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepNative) Reset() { *m = NidRepNative{} } +func (*NidRepNative) ProtoMessage() {} + +type NinRepNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepNative) Reset() { *m = NinRepNative{} } +func (*NinRepNative) ProtoMessage() {} + +type NidRepPackedNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepPackedNative) Reset() { *m = NidRepPackedNative{} } +func (*NidRepPackedNative) ProtoMessage() {} + +type NinRepPackedNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepPackedNative) Reset() { *m = NinRepPackedNative{} } +func (*NinRepPackedNative) ProtoMessage() {} + +type NidOptStruct struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + Field3 NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3"` + Field4 NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4"` + Field6 uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + Field8 NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8"` + Field13 bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + Field14 string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptStruct) Reset() { *m = NidOptStruct{} } +func (*NidOptStruct) ProtoMessage() {} + +type NinOptStruct struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field8 *NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptStruct) Reset() { *m = NinOptStruct{} } +func (*NinOptStruct) ProtoMessage() {} + +type NidRepStruct struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []NidOptNative `protobuf:"bytes,3,rep,name=Field3" json:"Field3"` + Field4 []NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []NidOptNative `protobuf:"bytes,8,rep,name=Field8" json:"Field8"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepStruct) Reset() { *m = NidRepStruct{} } +func (*NidRepStruct) ProtoMessage() {} + +type NinRepStruct struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []*NidOptNative `protobuf:"bytes,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []*NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []*NidOptNative `protobuf:"bytes,8,rep,name=Field8" json:"Field8,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepStruct) Reset() { *m = NinRepStruct{} } +func (*NinRepStruct) ProtoMessage() {} + +type NidEmbeddedStruct struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 NidOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200"` + Field210 bool `protobuf:"varint,210,opt,name=Field210" json:"Field210"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidEmbeddedStruct) Reset() { *m = NidEmbeddedStruct{} } +func (*NidEmbeddedStruct) ProtoMessage() {} + +type NinEmbeddedStruct struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 *NidOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + Field210 *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinEmbeddedStruct) Reset() { *m = NinEmbeddedStruct{} } +func (*NinEmbeddedStruct) ProtoMessage() {} + +type NidNestedStruct struct { + Field1 NidOptStruct `protobuf:"bytes,1,opt,name=Field1" json:"Field1"` + Field2 []NidRepStruct `protobuf:"bytes,2,rep,name=Field2" json:"Field2"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidNestedStruct) Reset() { *m = NidNestedStruct{} } +func (*NidNestedStruct) ProtoMessage() {} + +type NinNestedStruct struct { + Field1 *NinOptStruct `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 []*NinRepStruct `protobuf:"bytes,2,rep,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinNestedStruct) Reset() { *m = NinNestedStruct{} } +func (*NinNestedStruct) ProtoMessage() {} + +type NidOptCustom struct { + Id Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id"` + Value github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptCustom) Reset() { *m = NidOptCustom{} } +func (*NidOptCustom) ProtoMessage() {} + +type CustomDash struct { + Value *github_com_gogo_protobuf_test_custom_dash_type.Bytes `protobuf:"bytes,1,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom-dash-type.Bytes" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomDash) Reset() { *m = CustomDash{} } +func (*CustomDash) ProtoMessage() {} + +type NinOptCustom struct { + Id *Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id,omitempty"` + Value *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptCustom) Reset() { *m = NinOptCustom{} } +func (*NinOptCustom) ProtoMessage() {} + +type NidRepCustom struct { + Id []Uuid `protobuf:"bytes,1,rep,name=Id,customtype=Uuid" json:"Id"` + Value []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepCustom) Reset() { *m = NidRepCustom{} } +func (*NidRepCustom) ProtoMessage() {} + +type NinRepCustom struct { + Id []Uuid `protobuf:"bytes,1,rep,name=Id,customtype=Uuid" json:"Id,omitempty"` + Value []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepCustom) Reset() { *m = NinRepCustom{} } +func (*NinRepCustom) ProtoMessage() {} + +type NinOptNativeUnion struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNativeUnion) Reset() { *m = NinOptNativeUnion{} } +func (*NinOptNativeUnion) ProtoMessage() {} + +type NinOptStructUnion struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptStructUnion) Reset() { *m = NinOptStructUnion{} } +func (*NinOptStructUnion) ProtoMessage() {} + +type NinEmbeddedStructUnion struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 *NinOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + Field210 *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinEmbeddedStructUnion) Reset() { *m = NinEmbeddedStructUnion{} } +func (*NinEmbeddedStructUnion) ProtoMessage() {} + +type NinNestedStructUnion struct { + Field1 *NinOptNativeUnion `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *NinOptStructUnion `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NinEmbeddedStructUnion `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinNestedStructUnion) Reset() { *m = NinNestedStructUnion{} } +func (*NinNestedStructUnion) ProtoMessage() {} + +type Tree struct { + Or *OrBranch `protobuf:"bytes,1,opt,name=Or" json:"Or,omitempty"` + And *AndBranch `protobuf:"bytes,2,opt,name=And" json:"And,omitempty"` + Leaf *Leaf `protobuf:"bytes,3,opt,name=Leaf" json:"Leaf,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Tree) Reset() { *m = Tree{} } +func (*Tree) ProtoMessage() {} + +type OrBranch struct { + Left Tree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right Tree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OrBranch) Reset() { *m = OrBranch{} } +func (*OrBranch) ProtoMessage() {} + +type AndBranch struct { + Left Tree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right Tree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AndBranch) Reset() { *m = AndBranch{} } +func (*AndBranch) ProtoMessage() {} + +type Leaf struct { + Value int64 `protobuf:"varint,1,opt,name=Value" json:"Value"` + StrValue string `protobuf:"bytes,2,opt,name=StrValue" json:"StrValue"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Leaf) Reset() { *m = Leaf{} } +func (*Leaf) ProtoMessage() {} + +type DeepTree struct { + Down *ADeepBranch `protobuf:"bytes,1,opt,name=Down" json:"Down,omitempty"` + And *AndDeepBranch `protobuf:"bytes,2,opt,name=And" json:"And,omitempty"` + Leaf *DeepLeaf `protobuf:"bytes,3,opt,name=Leaf" json:"Leaf,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeepTree) Reset() { *m = DeepTree{} } +func (*DeepTree) ProtoMessage() {} + +type ADeepBranch struct { + Down DeepTree `protobuf:"bytes,2,opt,name=Down" json:"Down"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ADeepBranch) Reset() { *m = ADeepBranch{} } +func (*ADeepBranch) ProtoMessage() {} + +type AndDeepBranch struct { + Left DeepTree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right DeepTree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AndDeepBranch) Reset() { *m = AndDeepBranch{} } +func (*AndDeepBranch) ProtoMessage() {} + +type DeepLeaf struct { + Tree Tree `protobuf:"bytes,1,opt,name=Tree" json:"Tree"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeepLeaf) Reset() { *m = DeepLeaf{} } +func (*DeepLeaf) ProtoMessage() {} + +type Nil struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *Nil) Reset() { *m = Nil{} } +func (*Nil) ProtoMessage() {} + +type NidOptEnum struct { + Field1 TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptEnum) Reset() { *m = NidOptEnum{} } +func (*NidOptEnum) ProtoMessage() {} + +type NinOptEnum struct { + Field1 *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptEnum) Reset() { *m = NinOptEnum{} } +func (*NinOptEnum) ProtoMessage() {} + +type NidRepEnum struct { + Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepEnum) Reset() { *m = NidRepEnum{} } +func (*NidRepEnum) ProtoMessage() {} + +type NinRepEnum struct { + Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepEnum) Reset() { *m = NinRepEnum{} } +func (*NinRepEnum) ProtoMessage() {} + +type NinOptEnumDefault struct { + Field1 *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum,def=2" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptEnumDefault) Reset() { *m = NinOptEnumDefault{} } +func (*NinOptEnumDefault) ProtoMessage() {} + +const Default_NinOptEnumDefault_Field1 TheTestEnum = C + +func (m *NinOptEnumDefault) GetField1() TheTestEnum { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_NinOptEnumDefault_Field1 +} + +type AnotherNinOptEnum struct { + Field1 *AnotherTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.AnotherTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AnotherNinOptEnum) Reset() { *m = AnotherNinOptEnum{} } +func (*AnotherNinOptEnum) ProtoMessage() {} + +type AnotherNinOptEnumDefault struct { + Field1 *AnotherTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.AnotherTestEnum,def=11" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AnotherNinOptEnumDefault) Reset() { *m = AnotherNinOptEnumDefault{} } +func (*AnotherNinOptEnumDefault) ProtoMessage() {} + +const Default_AnotherNinOptEnumDefault_Field1 AnotherTestEnum = E + +func (m *AnotherNinOptEnumDefault) GetField1() AnotherTestEnum { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_AnotherNinOptEnumDefault_Field1 +} + +type Timer struct { + Time1 int64 `protobuf:"fixed64,1,opt,name=Time1" json:"Time1"` + Time2 int64 `protobuf:"fixed64,2,opt,name=Time2" json:"Time2"` + Data []byte `protobuf:"bytes,3,opt,name=Data" json:"Data"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Timer) Reset() { *m = Timer{} } +func (*Timer) ProtoMessage() {} + +type MyExtendable struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MyExtendable) Reset() { *m = MyExtendable{} } +func (*MyExtendable) ProtoMessage() {} + +var extRange_MyExtendable = []proto.ExtensionRange{ + {100, 199}, +} + +func (*MyExtendable) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MyExtendable +} +func (m *MyExtendable) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type OtherExtenable struct { + Field2 *int64 `protobuf:"varint,2,opt,name=Field2" json:"Field2,omitempty"` + Field13 *int64 `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + M *MyExtendable `protobuf:"bytes,1,opt,name=M" json:"M,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OtherExtenable) Reset() { *m = OtherExtenable{} } +func (*OtherExtenable) ProtoMessage() {} + +var extRange_OtherExtenable = []proto.ExtensionRange{ + {14, 16}, + {10, 12}, +} + +func (*OtherExtenable) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_OtherExtenable +} +func (m *OtherExtenable) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type NestedDefinition struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + EnumField *NestedDefinition_NestedEnum `protobuf:"varint,2,opt,name=EnumField,enum=test.NestedDefinition_NestedEnum" json:"EnumField,omitempty"` + NNM *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,3,opt,name=NNM" json:"NNM,omitempty"` + NM *NestedDefinition_NestedMessage `protobuf:"bytes,4,opt,name=NM" json:"NM,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition) Reset() { *m = NestedDefinition{} } +func (*NestedDefinition) ProtoMessage() {} + +type NestedDefinition_NestedMessage struct { + NestedField1 *uint64 `protobuf:"fixed64,1,opt,name=NestedField1" json:"NestedField1,omitempty"` + NNM *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,2,opt,name=NNM" json:"NNM,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition_NestedMessage) Reset() { *m = NestedDefinition_NestedMessage{} } +func (*NestedDefinition_NestedMessage) ProtoMessage() {} + +type NestedDefinition_NestedMessage_NestedNestedMsg struct { + NestedNestedField1 *string `protobuf:"bytes,10,opt,name=NestedNestedField1" json:"NestedNestedField1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Reset() { + *m = NestedDefinition_NestedMessage_NestedNestedMsg{} +} +func (*NestedDefinition_NestedMessage_NestedNestedMsg) ProtoMessage() {} + +type NestedScope struct { + A *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,1,opt,name=A" json:"A,omitempty"` + B *NestedDefinition_NestedEnum `protobuf:"varint,2,opt,name=B,enum=test.NestedDefinition_NestedEnum" json:"B,omitempty"` + C *NestedDefinition_NestedMessage `protobuf:"bytes,3,opt,name=C" json:"C,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedScope) Reset() { *m = NestedScope{} } +func (*NestedScope) ProtoMessage() {} + +type NinOptNativeDefault struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1,def=1234.1234" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2,def=1234.1234" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3,def=1234" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4,def=1234" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5,def=1234" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6,def=1234" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7,def=1234" json:"Field7,omitempty"` + Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8,def=1234" json:"Field8,omitempty"` + Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9,def=1234" json:"Field9,omitempty"` + Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10,def=1234" json:"Field10,omitempty"` + Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11,def=1234" json:"Field11,omitempty"` + Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12,def=1234" json:"Field12,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13,def=1" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14,def=1234" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNativeDefault) Reset() { *m = NinOptNativeDefault{} } +func (*NinOptNativeDefault) ProtoMessage() {} + +const Default_NinOptNativeDefault_Field1 float64 = 1234.1234 +const Default_NinOptNativeDefault_Field2 float32 = 1234.1234 +const Default_NinOptNativeDefault_Field3 int32 = 1234 +const Default_NinOptNativeDefault_Field4 int64 = 1234 +const Default_NinOptNativeDefault_Field5 uint32 = 1234 +const Default_NinOptNativeDefault_Field6 uint64 = 1234 +const Default_NinOptNativeDefault_Field7 int32 = 1234 +const Default_NinOptNativeDefault_Field8 int64 = 1234 +const Default_NinOptNativeDefault_Field9 uint32 = 1234 +const Default_NinOptNativeDefault_Field10 int32 = 1234 +const Default_NinOptNativeDefault_Field11 uint64 = 1234 +const Default_NinOptNativeDefault_Field12 int64 = 1234 +const Default_NinOptNativeDefault_Field13 bool = true +const Default_NinOptNativeDefault_Field14 string = "1234" + +func (m *NinOptNativeDefault) GetField1() float64 { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_NinOptNativeDefault_Field1 +} + +func (m *NinOptNativeDefault) GetField2() float32 { + if m != nil && m.Field2 != nil { + return *m.Field2 + } + return Default_NinOptNativeDefault_Field2 +} + +func (m *NinOptNativeDefault) GetField3() int32 { + if m != nil && m.Field3 != nil { + return *m.Field3 + } + return Default_NinOptNativeDefault_Field3 +} + +func (m *NinOptNativeDefault) GetField4() int64 { + if m != nil && m.Field4 != nil { + return *m.Field4 + } + return Default_NinOptNativeDefault_Field4 +} + +func (m *NinOptNativeDefault) GetField5() uint32 { + if m != nil && m.Field5 != nil { + return *m.Field5 + } + return Default_NinOptNativeDefault_Field5 +} + +func (m *NinOptNativeDefault) GetField6() uint64 { + if m != nil && m.Field6 != nil { + return *m.Field6 + } + return Default_NinOptNativeDefault_Field6 +} + +func (m *NinOptNativeDefault) GetField7() int32 { + if m != nil && m.Field7 != nil { + return *m.Field7 + } + return Default_NinOptNativeDefault_Field7 +} + +func (m *NinOptNativeDefault) GetField8() int64 { + if m != nil && m.Field8 != nil { + return *m.Field8 + } + return Default_NinOptNativeDefault_Field8 +} + +func (m *NinOptNativeDefault) GetField9() uint32 { + if m != nil && m.Field9 != nil { + return *m.Field9 + } + return Default_NinOptNativeDefault_Field9 +} + +func (m *NinOptNativeDefault) GetField10() int32 { + if m != nil && m.Field10 != nil { + return *m.Field10 + } + return Default_NinOptNativeDefault_Field10 +} + +func (m *NinOptNativeDefault) GetField11() uint64 { + if m != nil && m.Field11 != nil { + return *m.Field11 + } + return Default_NinOptNativeDefault_Field11 +} + +func (m *NinOptNativeDefault) GetField12() int64 { + if m != nil && m.Field12 != nil { + return *m.Field12 + } + return Default_NinOptNativeDefault_Field12 +} + +func (m *NinOptNativeDefault) GetField13() bool { + if m != nil && m.Field13 != nil { + return *m.Field13 + } + return Default_NinOptNativeDefault_Field13 +} + +func (m *NinOptNativeDefault) GetField14() string { + if m != nil && m.Field14 != nil { + return *m.Field14 + } + return Default_NinOptNativeDefault_Field14 +} + +func (m *NinOptNativeDefault) GetField15() []byte { + if m != nil { + return m.Field15 + } + return nil +} + +type CustomContainer struct { + CustomStruct NidOptCustom `protobuf:"bytes,1,opt,name=CustomStruct" json:"CustomStruct"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomContainer) Reset() { *m = CustomContainer{} } +func (*CustomContainer) ProtoMessage() {} + +type CustomNameNidOptNative struct { + FieldA float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + FieldB float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + FieldC int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3"` + FieldD int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4"` + FieldE uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5"` + FieldF uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + FieldG int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + FieldH int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8"` + FieldI uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9"` + FieldJ int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10"` + FieldK uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11"` + FieldL int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12"` + FieldM bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + FieldN string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + FieldO []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNidOptNative) Reset() { *m = CustomNameNidOptNative{} } +func (*CustomNameNidOptNative) ProtoMessage() {} + +type CustomNameNinOptNative struct { + FieldA *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + FieldB *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + FieldC *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + FieldD *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + FieldE *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + FieldF *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + FieldG *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + FieldH *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"` + FieldI *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"` + FieldJ *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"` + FieldK *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"` + FielL *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"` + FieldM *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + FieldN *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + FieldO []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinOptNative) Reset() { *m = CustomNameNinOptNative{} } +func (*CustomNameNinOptNative) ProtoMessage() {} + +type CustomNameNinRepNative struct { + FieldA []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + FieldB []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + FieldC []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + FieldD []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + FieldE []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + FieldF []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + FieldG []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + FieldH []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + FieldI []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + FieldJ []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + FieldK []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + FieldL []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + FieldM []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + FieldN []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + FieldO [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinRepNative) Reset() { *m = CustomNameNinRepNative{} } +func (*CustomNameNinRepNative) ProtoMessage() {} + +type CustomNameNinStruct struct { + FieldA *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + FieldB *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + FieldC *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + FieldD []*NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4,omitempty"` + FieldE *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + FieldF *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + FieldG *NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"` + FieldH *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + FieldI *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + FieldJ []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinStruct) Reset() { *m = CustomNameNinStruct{} } +func (*CustomNameNinStruct) ProtoMessage() {} + +type CustomNameCustomType struct { + FieldA *Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id,omitempty"` + FieldB *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + FieldC []Uuid `protobuf:"bytes,3,rep,name=Ids,customtype=Uuid" json:"Ids,omitempty"` + FieldD []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,4,rep,name=Values,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Values,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameCustomType) Reset() { *m = CustomNameCustomType{} } +func (*CustomNameCustomType) ProtoMessage() {} + +type CustomNameNinEmbeddedStructUnion struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + FieldA *NinOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + FieldB *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinEmbeddedStructUnion) Reset() { *m = CustomNameNinEmbeddedStructUnion{} } +func (*CustomNameNinEmbeddedStructUnion) ProtoMessage() {} + +type CustomNameEnum struct { + FieldA *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + FieldB []TheTestEnum `protobuf:"varint,2,rep,name=Field2,enum=test.TheTestEnum" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameEnum) Reset() { *m = CustomNameEnum{} } +func (*CustomNameEnum) ProtoMessage() {} + +type NoExtensionsMap struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + XXX_extensions []byte `protobuf:"bytes,0,opt" json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NoExtensionsMap) Reset() { *m = NoExtensionsMap{} } +func (*NoExtensionsMap) ProtoMessage() {} + +var extRange_NoExtensionsMap = []proto.ExtensionRange{ + {100, 199}, +} + +func (*NoExtensionsMap) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_NoExtensionsMap +} +func (m *NoExtensionsMap) GetExtensions() *[]byte { + if m.XXX_extensions == nil { + m.XXX_extensions = make([]byte, 0) + } + return &m.XXX_extensions +} + +type Unrecognized struct { + Field1 *string `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *Unrecognized) Reset() { *m = Unrecognized{} } +func (*Unrecognized) ProtoMessage() {} + +type UnrecognizedWithInner struct { + Embedded []*UnrecognizedWithInner_Inner `protobuf:"bytes,1,rep,name=embedded" json:"embedded,omitempty"` + Field2 *string `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnrecognizedWithInner) Reset() { *m = UnrecognizedWithInner{} } +func (*UnrecognizedWithInner) ProtoMessage() {} + +type UnrecognizedWithInner_Inner struct { + Field1 *uint32 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *UnrecognizedWithInner_Inner) Reset() { *m = UnrecognizedWithInner_Inner{} } +func (*UnrecognizedWithInner_Inner) ProtoMessage() {} + +type UnrecognizedWithEmbed struct { + UnrecognizedWithEmbed_Embedded `protobuf:"bytes,1,opt,name=embedded,embedded=embedded" json:"embedded"` + Field2 *string `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnrecognizedWithEmbed) Reset() { *m = UnrecognizedWithEmbed{} } +func (*UnrecognizedWithEmbed) ProtoMessage() {} + +type UnrecognizedWithEmbed_Embedded struct { + Field1 *uint32 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *UnrecognizedWithEmbed_Embedded) Reset() { *m = UnrecognizedWithEmbed_Embedded{} } +func (*UnrecognizedWithEmbed_Embedded) ProtoMessage() {} + +var E_FieldA = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*float64)(nil), + Field: 100, + Name: "test.FieldA", + Tag: "fixed64,100,opt,name=FieldA", +} + +var E_FieldB = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*NinOptNative)(nil), + Field: 101, + Name: "test.FieldB", + Tag: "bytes,101,opt,name=FieldB", +} + +var E_FieldC = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*NinEmbeddedStruct)(nil), + Field: 102, + Name: "test.FieldC", + Tag: "bytes,102,opt,name=FieldC", +} + +var E_FieldA1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*float64)(nil), + Field: 100, + Name: "test.FieldA1", + Tag: "fixed64,100,opt,name=FieldA1", +} + +var E_FieldB1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*NinOptNative)(nil), + Field: 101, + Name: "test.FieldB1", + Tag: "bytes,101,opt,name=FieldB1", +} + +var E_FieldC1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*NinEmbeddedStruct)(nil), + Field: 102, + Name: "test.FieldC1", + Tag: "bytes,102,opt,name=FieldC1", +} + +func init() { + proto.RegisterEnum("test.TheTestEnum", TheTestEnum_name, TheTestEnum_value) + proto.RegisterEnum("test.AnotherTestEnum", AnotherTestEnum_name, AnotherTestEnum_value) + proto.RegisterEnum("test.NestedDefinition_NestedEnum", NestedDefinition_NestedEnum_name, NestedDefinition_NestedEnum_value) + proto.RegisterExtension(E_FieldA) + proto.RegisterExtension(E_FieldB) + proto.RegisterExtension(E_FieldC) + proto.RegisterExtension(E_FieldA1) + proto.RegisterExtension(E_FieldB1) + proto.RegisterExtension(E_FieldC1) +} +func (this *NidOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepPackedNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepPackedNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidEmbeddedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinEmbeddedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidNestedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinNestedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomDash) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNativeUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinEmbeddedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinNestedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Tree) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *OrBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AndBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Leaf) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *DeepTree) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *ADeepBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AndDeepBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *DeepLeaf) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Nil) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptEnumDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AnotherNinOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AnotherNinOptEnumDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Timer) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *MyExtendable) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *OtherExtenable) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition_NestedMessage) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedScope) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNativeDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomContainer) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNidOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameCustomType) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinEmbeddedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NoExtensionsMap) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Unrecognized) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithInner) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithInner_Inner) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithEmbed) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithEmbed_Embedded) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func ThetestDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/marshaler/thetest.proto"), + Package: func(v string) *string { return &v }("test"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NinRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NidOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }, {Name: func(v string) *string { return &v }("NidNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidRepStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStruct"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinRepStruct"), + }}, + }, {Name: func(v string) *string { return &v }("NidOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomDash"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x64, 0x61, 0x73, 0x68, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NidRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinOptStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinNestedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNativeUnion"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStructUnion"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStructUnion"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Tree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Or"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.OrBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Leaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("OrBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Leaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("StrValue"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepTree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.ADeepBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndDeepBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepLeaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("ADeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndDeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepLeaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Tree"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Nil")}, {Name: func(v string) *string { return &v }("NidOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NidRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + DefaultValue: func(v string) *string { return &v }("C"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + DefaultValue: func(v string) *string { return &v }("E"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Timer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Time1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Time2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Data"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("MyExtendable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("OtherExtenable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("M"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.MyExtendable"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(14), + End: func(v int32) *int32 { return &v }(17), + }, {Start: func(v int32) *int32 { return &v }(10), + End: func(v int32) *int32 { return &v }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("NestedDefinition"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("EnumField"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("NM"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedMessage"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedField1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedMsg"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedField1"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("NestedEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_NESTED"), + Number: func(v int32) *int32 { return &v }(1), + }}, + }}, + }, {Name: func(v string) *string { return &v }("NestedScope"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("true"), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("CustomContainer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("CustomStruct"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptCustom"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x5, 0x46, 0x69, 0x65, 0x6c, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameCustomType"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Ids"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Values"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("CustomNameEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + }, {Name: func(v string) *string { return &v }("NoExtensionsMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0}), 64025: proto.NewExtension([]byte{0xc8, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Unrecognized"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithInner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithInner.Inner"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Inner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithEmbed"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithEmbed.Embedded"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Embedded"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("TheTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }, {Name: func(v string) *string { return &v }("AnotherTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("D"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("E"), + Number: func(v int32) *int32 { return &v }(11), + }}, + Options: &google_protobuf.EnumOptions{XXX_extensions: map[int32]proto.Extension{62001: proto.NewExtension([]byte{0x88, 0xa3, 0x1e, 0x0})}}, + }}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("FieldA"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldB"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldC"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldA1"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldB1"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldC1"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (x TheTestEnum) String() string { + s, ok := TheTestEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x AnotherTestEnum) String() string { + s, ok := AnotherTestEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x NestedDefinition_NestedEnum) String() string { + s, ok := NestedDefinition_NestedEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *NidOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptNative) + if !ok { + return fmt.Errorf("that is not of type *NidOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptNativebut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if this.Field2 != that1.Field2 { + return false + } + if this.Field3 != that1.Field3 { + return false + } + if this.Field4 != that1.Field4 { + return false + } + if this.Field5 != that1.Field5 { + return false + } + if this.Field6 != that1.Field6 { + return false + } + if this.Field7 != that1.Field7 { + return false + } + if this.Field8 != that1.Field8 { + return false + } + if this.Field9 != that1.Field9 { + return false + } + if this.Field10 != that1.Field10 { + return false + } + if this.Field11 != that1.Field11 { + return false + } + if this.Field12 != that1.Field12 { + return false + } + if this.Field13 != that1.Field13 { + return false + } + if this.Field14 != that1.Field14 { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNative) + if !ok { + return fmt.Errorf("that is not of type *NinOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativebut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", *this.Field8, *that1.Field8) + } + } else if this.Field8 != nil { + return fmt.Errorf("this.Field8 == nil && that.Field8 != nil") + } else if that1.Field8 != nil { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", *this.Field9, *that1.Field9) + } + } else if this.Field9 != nil { + return fmt.Errorf("this.Field9 == nil && that.Field9 != nil") + } else if that1.Field9 != nil { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", *this.Field10, *that1.Field10) + } + } else if this.Field10 != nil { + return fmt.Errorf("this.Field10 == nil && that.Field10 != nil") + } else if that1.Field10 != nil { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", *this.Field11, *that1.Field11) + } + } else if this.Field11 != nil { + return fmt.Errorf("this.Field11 == nil && that.Field11 != nil") + } else if that1.Field11 != nil { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", *this.Field12, *that1.Field12) + } + } else if this.Field12 != nil { + return fmt.Errorf("this.Field12 == nil && that.Field12 != nil") + } else if that1.Field12 != nil { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return false + } + } else if this.Field8 != nil { + return false + } else if that1.Field8 != nil { + return false + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return false + } + } else if this.Field9 != nil { + return false + } else if that1.Field9 != nil { + return false + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return false + } + } else if this.Field10 != nil { + return false + } else if that1.Field10 != nil { + return false + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return false + } + } else if this.Field11 != nil { + return false + } else if that1.Field11 != nil { + return false + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return false + } + } else if this.Field12 != nil { + return false + } else if that1.Field12 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepNative) + if !ok { + return fmt.Errorf("that is not of type *NidRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepNative) + if !ok { + return fmt.Errorf("that is not of type *NinRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepPackedNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepPackedNative) + if !ok { + return fmt.Errorf("that is not of type *NidRepPackedNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepPackedNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepPackedNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepPackedNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepPackedNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepPackedNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepPackedNative) + if !ok { + return fmt.Errorf("that is not of type *NinRepPackedNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepPackedNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepPackedNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepPackedNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepPackedNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptStruct) + if !ok { + return fmt.Errorf("that is not of type *NidOptStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptStructbut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(&that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(&that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if !this.Field8.Equal(&that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if this.Field2 != that1.Field2 { + return false + } + if !this.Field3.Equal(&that1.Field3) { + return false + } + if !this.Field4.Equal(&that1.Field4) { + return false + } + if this.Field6 != that1.Field6 { + return false + } + if this.Field7 != that1.Field7 { + return false + } + if !this.Field8.Equal(&that1.Field8) { + return false + } + if this.Field13 != that1.Field13 { + return false + } + if this.Field14 != that1.Field14 { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptStruct) + if !ok { + return fmt.Errorf("that is not of type *NinOptStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptStructbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if !this.Field8.Equal(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !this.Field4.Equal(that1.Field4) { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if !this.Field8.Equal(that1.Field8) { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepStruct) + if !ok { + return fmt.Errorf("that is not of type *NidRepStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepStructbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if !this.Field3[i].Equal(&that1.Field3[i]) { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if !this.Field4[i].Equal(&that1.Field4[i]) { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if !this.Field8[i].Equal(&that1.Field8[i]) { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if !this.Field3[i].Equal(&that1.Field3[i]) { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if !this.Field4[i].Equal(&that1.Field4[i]) { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if !this.Field8[i].Equal(&that1.Field8[i]) { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepStruct) + if !ok { + return fmt.Errorf("that is not of type *NinRepStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepStructbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if !this.Field3[i].Equal(that1.Field3[i]) { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if !this.Field4[i].Equal(that1.Field4[i]) { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if !this.Field8[i].Equal(that1.Field8[i]) { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if !this.Field3[i].Equal(that1.Field3[i]) { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if !this.Field4[i].Equal(that1.Field4[i]) { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if !this.Field8[i].Equal(that1.Field8[i]) { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidEmbeddedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidEmbeddedStruct) + if !ok { + return fmt.Errorf("that is not of type *NidEmbeddedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidEmbeddedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidEmbeddedStructbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(&that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidEmbeddedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidEmbeddedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(&that1.Field200) { + return false + } + if this.Field210 != that1.Field210 { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinEmbeddedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinEmbeddedStruct) + if !ok { + return fmt.Errorf("that is not of type *NinEmbeddedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinEmbeddedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinEmbeddedStructbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", *this.Field210, *that1.Field210) + } + } else if this.Field210 != nil { + return fmt.Errorf("this.Field210 == nil && that.Field210 != nil") + } else if that1.Field210 != nil { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinEmbeddedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinEmbeddedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(that1.Field200) { + return false + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return false + } + } else if this.Field210 != nil { + return false + } else if that1.Field210 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidNestedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidNestedStruct) + if !ok { + return fmt.Errorf("that is not of type *NidNestedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidNestedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidNestedStructbut is not nil && this == nil") + } + if !this.Field1.Equal(&that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if !this.Field2[i].Equal(&that1.Field2[i]) { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidNestedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidNestedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(&that1.Field1) { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if !this.Field2[i].Equal(&that1.Field2[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinNestedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinNestedStruct) + if !ok { + return fmt.Errorf("that is not of type *NinNestedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinNestedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinNestedStructbut is not nil && this == nil") + } + if !this.Field1.Equal(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if !this.Field2[i].Equal(that1.Field2[i]) { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinNestedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinNestedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(that1.Field1) { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if !this.Field2[i].Equal(that1.Field2[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptCustom) + if !ok { + return fmt.Errorf("that is not of type *NidOptCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptCustombut is not nil && this == nil") + } + if !this.Id.Equal(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id) + } + if !this.Value.Equal(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Id.Equal(that1.Id) { + return false + } + if !this.Value.Equal(that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomDash) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomDash) + if !ok { + return fmt.Errorf("that is not of type *CustomDash") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomDash but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomDashbut is not nil && this == nil") + } + if that1.Value == nil { + if this.Value != nil { + return fmt.Errorf("this.Value != nil && that1.Value == nil") + } + } else if !this.Value.Equal(*that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomDash) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomDash) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Value == nil { + if this.Value != nil { + return false + } + } else if !this.Value.Equal(*that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptCustom) + if !ok { + return fmt.Errorf("that is not of type *NinOptCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptCustombut is not nil && this == nil") + } + if that1.Id == nil { + if this.Id != nil { + return fmt.Errorf("this.Id != nil && that1.Id == nil") + } + } else if !this.Id.Equal(*that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id) + } + if that1.Value == nil { + if this.Value != nil { + return fmt.Errorf("this.Value != nil && that1.Value == nil") + } + } else if !this.Value.Equal(*that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Id == nil { + if this.Id != nil { + return false + } + } else if !this.Id.Equal(*that1.Id) { + return false + } + if that1.Value == nil { + if this.Value != nil { + return false + } + } else if !this.Value.Equal(*that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepCustom) + if !ok { + return fmt.Errorf("that is not of type *NidRepCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepCustombut is not nil && this == nil") + } + if len(this.Id) != len(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", len(this.Id), len(that1.Id)) + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return fmt.Errorf("Id this[%v](%v) Not Equal that[%v](%v)", i, this.Id[i], i, that1.Id[i]) + } + } + if len(this.Value) != len(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", len(this.Value), len(that1.Value)) + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return fmt.Errorf("Value this[%v](%v) Not Equal that[%v](%v)", i, this.Value[i], i, that1.Value[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Id) != len(that1.Id) { + return false + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return false + } + } + if len(this.Value) != len(that1.Value) { + return false + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepCustom) + if !ok { + return fmt.Errorf("that is not of type *NinRepCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepCustombut is not nil && this == nil") + } + if len(this.Id) != len(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", len(this.Id), len(that1.Id)) + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return fmt.Errorf("Id this[%v](%v) Not Equal that[%v](%v)", i, this.Id[i], i, that1.Id[i]) + } + } + if len(this.Value) != len(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", len(this.Value), len(that1.Value)) + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return fmt.Errorf("Value this[%v](%v) Not Equal that[%v](%v)", i, this.Value[i], i, that1.Value[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Id) != len(that1.Id) { + return false + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return false + } + } + if len(this.Value) != len(that1.Value) { + return false + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNativeUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNativeUnion) + if !ok { + return fmt.Errorf("that is not of type *NinOptNativeUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNativeUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativeUnionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNativeUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNativeUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinOptStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptStructUnionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !this.Field4.Equal(that1.Field4) { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinEmbeddedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinEmbeddedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinEmbeddedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinEmbeddedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinEmbeddedStructUnionbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", *this.Field210, *that1.Field210) + } + } else if this.Field210 != nil { + return fmt.Errorf("this.Field210 == nil && that.Field210 != nil") + } else if that1.Field210 != nil { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinEmbeddedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinEmbeddedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(that1.Field200) { + return false + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return false + } + } else if this.Field210 != nil { + return false + } else if that1.Field210 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinNestedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinNestedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinNestedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinNestedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinNestedStructUnionbut is not nil && this == nil") + } + if !this.Field1.Equal(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !this.Field2.Equal(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinNestedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinNestedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(that1.Field1) { + return false + } + if !this.Field2.Equal(that1.Field2) { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Tree) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Tree) + if !ok { + return fmt.Errorf("that is not of type *Tree") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Tree but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Treebut is not nil && this == nil") + } + if !this.Or.Equal(that1.Or) { + return fmt.Errorf("Or this(%v) Not Equal that(%v)", this.Or, that1.Or) + } + if !this.And.Equal(that1.And) { + return fmt.Errorf("And this(%v) Not Equal that(%v)", this.And, that1.And) + } + if !this.Leaf.Equal(that1.Leaf) { + return fmt.Errorf("Leaf this(%v) Not Equal that(%v)", this.Leaf, that1.Leaf) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Tree) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Tree) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Or.Equal(that1.Or) { + return false + } + if !this.And.Equal(that1.And) { + return false + } + if !this.Leaf.Equal(that1.Leaf) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OrBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OrBranch) + if !ok { + return fmt.Errorf("that is not of type *OrBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OrBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OrBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OrBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OrBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AndBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AndBranch) + if !ok { + return fmt.Errorf("that is not of type *AndBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AndBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AndBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AndBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AndBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Leaf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Leaf) + if !ok { + return fmt.Errorf("that is not of type *Leaf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Leaf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Leafbut is not nil && this == nil") + } + if this.Value != that1.Value { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if this.StrValue != that1.StrValue { + return fmt.Errorf("StrValue this(%v) Not Equal that(%v)", this.StrValue, that1.StrValue) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Leaf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Leaf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Value != that1.Value { + return false + } + if this.StrValue != that1.StrValue { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *DeepTree) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*DeepTree) + if !ok { + return fmt.Errorf("that is not of type *DeepTree") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *DeepTree but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *DeepTreebut is not nil && this == nil") + } + if !this.Down.Equal(that1.Down) { + return fmt.Errorf("Down this(%v) Not Equal that(%v)", this.Down, that1.Down) + } + if !this.And.Equal(that1.And) { + return fmt.Errorf("And this(%v) Not Equal that(%v)", this.And, that1.And) + } + if !this.Leaf.Equal(that1.Leaf) { + return fmt.Errorf("Leaf this(%v) Not Equal that(%v)", this.Leaf, that1.Leaf) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *DeepTree) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*DeepTree) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Down.Equal(that1.Down) { + return false + } + if !this.And.Equal(that1.And) { + return false + } + if !this.Leaf.Equal(that1.Leaf) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *ADeepBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*ADeepBranch) + if !ok { + return fmt.Errorf("that is not of type *ADeepBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *ADeepBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *ADeepBranchbut is not nil && this == nil") + } + if !this.Down.Equal(&that1.Down) { + return fmt.Errorf("Down this(%v) Not Equal that(%v)", this.Down, that1.Down) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *ADeepBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*ADeepBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Down.Equal(&that1.Down) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AndDeepBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AndDeepBranch) + if !ok { + return fmt.Errorf("that is not of type *AndDeepBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AndDeepBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AndDeepBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AndDeepBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AndDeepBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *DeepLeaf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*DeepLeaf) + if !ok { + return fmt.Errorf("that is not of type *DeepLeaf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *DeepLeaf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *DeepLeafbut is not nil && this == nil") + } + if !this.Tree.Equal(&that1.Tree) { + return fmt.Errorf("Tree this(%v) Not Equal that(%v)", this.Tree, that1.Tree) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *DeepLeaf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*DeepLeaf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Tree.Equal(&that1.Tree) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Nil) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Nil) + if !ok { + return fmt.Errorf("that is not of type *Nil") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Nil but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Nilbut is not nil && this == nil") + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Nil) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Nil) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptEnum) + if !ok { + return fmt.Errorf("that is not of type *NidOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptEnumbut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptEnum) + if !ok { + return fmt.Errorf("that is not of type *NinOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptEnumbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepEnum) + if !ok { + return fmt.Errorf("that is not of type *NidRepEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepEnumbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepEnum) + if !ok { + return fmt.Errorf("that is not of type *NinRepEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepEnumbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptEnumDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptEnumDefault) + if !ok { + return fmt.Errorf("that is not of type *NinOptEnumDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptEnumDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptEnumDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptEnumDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptEnumDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AnotherNinOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AnotherNinOptEnum) + if !ok { + return fmt.Errorf("that is not of type *AnotherNinOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AnotherNinOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AnotherNinOptEnumbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AnotherNinOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AnotherNinOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AnotherNinOptEnumDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AnotherNinOptEnumDefault) + if !ok { + return fmt.Errorf("that is not of type *AnotherNinOptEnumDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AnotherNinOptEnumDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AnotherNinOptEnumDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AnotherNinOptEnumDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AnotherNinOptEnumDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Timer) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Timer) + if !ok { + return fmt.Errorf("that is not of type *Timer") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Timer but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Timerbut is not nil && this == nil") + } + if this.Time1 != that1.Time1 { + return fmt.Errorf("Time1 this(%v) Not Equal that(%v)", this.Time1, that1.Time1) + } + if this.Time2 != that1.Time2 { + return fmt.Errorf("Time2 this(%v) Not Equal that(%v)", this.Time2, that1.Time2) + } + if !bytes.Equal(this.Data, that1.Data) { + return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Timer) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Timer) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Time1 != that1.Time1 { + return false + } + if this.Time2 != that1.Time2 { + return false + } + if !bytes.Equal(this.Data, that1.Data) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *MyExtendable) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*MyExtendable) + if !ok { + return fmt.Errorf("that is not of type *MyExtendable") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *MyExtendable but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *MyExtendablebut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return fmt.Errorf("XXX_extensions this[%v](%v) Not Equal that[%v](%v)", k, this.XXX_extensions[k], k, that1.XXX_extensions[k]) + } + } else { + return fmt.Errorf("XXX_extensions[%v] Not In that", k) + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return fmt.Errorf("XXX_extensions[%v] Not In this", k) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *MyExtendable) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*MyExtendable) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return false + } + } else { + return false + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OtherExtenable) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OtherExtenable) + if !ok { + return fmt.Errorf("that is not of type *OtherExtenable") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OtherExtenable but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OtherExtenablebut is not nil && this == nil") + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if !this.M.Equal(that1.M) { + return fmt.Errorf("M this(%v) Not Equal that(%v)", this.M, that1.M) + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return fmt.Errorf("XXX_extensions this[%v](%v) Not Equal that[%v](%v)", k, this.XXX_extensions[k], k, that1.XXX_extensions[k]) + } + } else { + return fmt.Errorf("XXX_extensions[%v] Not In that", k) + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return fmt.Errorf("XXX_extensions[%v] Not In this", k) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OtherExtenable) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OtherExtenable) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if !this.M.Equal(that1.M) { + return false + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return false + } + } else { + return false + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinitionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.EnumField != nil && that1.EnumField != nil { + if *this.EnumField != *that1.EnumField { + return fmt.Errorf("EnumField this(%v) Not Equal that(%v)", *this.EnumField, *that1.EnumField) + } + } else if this.EnumField != nil { + return fmt.Errorf("this.EnumField == nil && that.EnumField != nil") + } else if that1.EnumField != nil { + return fmt.Errorf("EnumField this(%v) Not Equal that(%v)", this.EnumField, that1.EnumField) + } + if !this.NNM.Equal(that1.NNM) { + return fmt.Errorf("NNM this(%v) Not Equal that(%v)", this.NNM, that1.NNM) + } + if !this.NM.Equal(that1.NM) { + return fmt.Errorf("NM this(%v) Not Equal that(%v)", this.NM, that1.NM) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.EnumField != nil && that1.EnumField != nil { + if *this.EnumField != *that1.EnumField { + return false + } + } else if this.EnumField != nil { + return false + } else if that1.EnumField != nil { + return false + } + if !this.NNM.Equal(that1.NNM) { + return false + } + if !this.NM.Equal(that1.NM) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition_NestedMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition_NestedMessage) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition_NestedMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition_NestedMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinition_NestedMessagebut is not nil && this == nil") + } + if this.NestedField1 != nil && that1.NestedField1 != nil { + if *this.NestedField1 != *that1.NestedField1 { + return fmt.Errorf("NestedField1 this(%v) Not Equal that(%v)", *this.NestedField1, *that1.NestedField1) + } + } else if this.NestedField1 != nil { + return fmt.Errorf("this.NestedField1 == nil && that.NestedField1 != nil") + } else if that1.NestedField1 != nil { + return fmt.Errorf("NestedField1 this(%v) Not Equal that(%v)", this.NestedField1, that1.NestedField1) + } + if !this.NNM.Equal(that1.NNM) { + return fmt.Errorf("NNM this(%v) Not Equal that(%v)", this.NNM, that1.NNM) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition_NestedMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition_NestedMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.NestedField1 != nil && that1.NestedField1 != nil { + if *this.NestedField1 != *that1.NestedField1 { + return false + } + } else if this.NestedField1 != nil { + return false + } else if that1.NestedField1 != nil { + return false + } + if !this.NNM.Equal(that1.NNM) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition_NestedMessage_NestedNestedMsg) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition_NestedMessage_NestedNestedMsg") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition_NestedMessage_NestedNestedMsg but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinition_NestedMessage_NestedNestedMsgbut is not nil && this == nil") + } + if this.NestedNestedField1 != nil && that1.NestedNestedField1 != nil { + if *this.NestedNestedField1 != *that1.NestedNestedField1 { + return fmt.Errorf("NestedNestedField1 this(%v) Not Equal that(%v)", *this.NestedNestedField1, *that1.NestedNestedField1) + } + } else if this.NestedNestedField1 != nil { + return fmt.Errorf("this.NestedNestedField1 == nil && that.NestedNestedField1 != nil") + } else if that1.NestedNestedField1 != nil { + return fmt.Errorf("NestedNestedField1 this(%v) Not Equal that(%v)", this.NestedNestedField1, that1.NestedNestedField1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition_NestedMessage_NestedNestedMsg) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.NestedNestedField1 != nil && that1.NestedNestedField1 != nil { + if *this.NestedNestedField1 != *that1.NestedNestedField1 { + return false + } + } else if this.NestedNestedField1 != nil { + return false + } else if that1.NestedNestedField1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedScope) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedScope) + if !ok { + return fmt.Errorf("that is not of type *NestedScope") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedScope but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedScopebut is not nil && this == nil") + } + if !this.A.Equal(that1.A) { + return fmt.Errorf("A this(%v) Not Equal that(%v)", this.A, that1.A) + } + if this.B != nil && that1.B != nil { + if *this.B != *that1.B { + return fmt.Errorf("B this(%v) Not Equal that(%v)", *this.B, *that1.B) + } + } else if this.B != nil { + return fmt.Errorf("this.B == nil && that.B != nil") + } else if that1.B != nil { + return fmt.Errorf("B this(%v) Not Equal that(%v)", this.B, that1.B) + } + if !this.C.Equal(that1.C) { + return fmt.Errorf("C this(%v) Not Equal that(%v)", this.C, that1.C) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedScope) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedScope) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.A.Equal(that1.A) { + return false + } + if this.B != nil && that1.B != nil { + if *this.B != *that1.B { + return false + } + } else if this.B != nil { + return false + } else if that1.B != nil { + return false + } + if !this.C.Equal(that1.C) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNativeDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNativeDefault) + if !ok { + return fmt.Errorf("that is not of type *NinOptNativeDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNativeDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativeDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", *this.Field8, *that1.Field8) + } + } else if this.Field8 != nil { + return fmt.Errorf("this.Field8 == nil && that.Field8 != nil") + } else if that1.Field8 != nil { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", *this.Field9, *that1.Field9) + } + } else if this.Field9 != nil { + return fmt.Errorf("this.Field9 == nil && that.Field9 != nil") + } else if that1.Field9 != nil { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", *this.Field10, *that1.Field10) + } + } else if this.Field10 != nil { + return fmt.Errorf("this.Field10 == nil && that.Field10 != nil") + } else if that1.Field10 != nil { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", *this.Field11, *that1.Field11) + } + } else if this.Field11 != nil { + return fmt.Errorf("this.Field11 == nil && that.Field11 != nil") + } else if that1.Field11 != nil { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", *this.Field12, *that1.Field12) + } + } else if this.Field12 != nil { + return fmt.Errorf("this.Field12 == nil && that.Field12 != nil") + } else if that1.Field12 != nil { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNativeDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNativeDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return false + } + } else if this.Field8 != nil { + return false + } else if that1.Field8 != nil { + return false + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return false + } + } else if this.Field9 != nil { + return false + } else if that1.Field9 != nil { + return false + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return false + } + } else if this.Field10 != nil { + return false + } else if that1.Field10 != nil { + return false + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return false + } + } else if this.Field11 != nil { + return false + } else if that1.Field11 != nil { + return false + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return false + } + } else if this.Field12 != nil { + return false + } else if that1.Field12 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomContainer) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomContainer) + if !ok { + return fmt.Errorf("that is not of type *CustomContainer") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomContainer but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomContainerbut is not nil && this == nil") + } + if !this.CustomStruct.Equal(&that1.CustomStruct) { + return fmt.Errorf("CustomStruct this(%v) Not Equal that(%v)", this.CustomStruct, that1.CustomStruct) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomContainer) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomContainer) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.CustomStruct.Equal(&that1.CustomStruct) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNidOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNidOptNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNidOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNidOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNidOptNativebut is not nil && this == nil") + } + if this.FieldA != that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if this.FieldC != that1.FieldC { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if this.FieldD != that1.FieldD { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", this.FieldD, that1.FieldD) + } + if this.FieldE != that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if this.FieldG != that1.FieldG { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if this.FieldJ != that1.FieldJ { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if this.FieldK != that1.FieldK { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", this.FieldK, that1.FieldK) + } + if this.FieldL != that1.FieldL { + return fmt.Errorf("FieldL this(%v) Not Equal that(%v)", this.FieldL, that1.FieldL) + } + if this.FieldM != that1.FieldM { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", this.FieldM, that1.FieldM) + } + if this.FieldN != that1.FieldN { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", this.FieldN, that1.FieldN) + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", this.FieldO, that1.FieldO) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNidOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNidOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != that1.FieldA { + return false + } + if this.FieldB != that1.FieldB { + return false + } + if this.FieldC != that1.FieldC { + return false + } + if this.FieldD != that1.FieldD { + return false + } + if this.FieldE != that1.FieldE { + return false + } + if this.FieldF != that1.FieldF { + return false + } + if this.FieldG != that1.FieldG { + return false + } + if this.FieldH != that1.FieldH { + return false + } + if this.FieldI != that1.FieldI { + return false + } + if this.FieldJ != that1.FieldJ { + return false + } + if this.FieldK != that1.FieldK { + return false + } + if this.FieldL != that1.FieldL { + return false + } + if this.FieldM != that1.FieldM { + return false + } + if this.FieldN != that1.FieldN { + return false + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinOptNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinOptNativebut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if this.FieldC != nil && that1.FieldC != nil { + if *this.FieldC != *that1.FieldC { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", *this.FieldC, *that1.FieldC) + } + } else if this.FieldC != nil { + return fmt.Errorf("this.FieldC == nil && that.FieldC != nil") + } else if that1.FieldC != nil { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if this.FieldD != nil && that1.FieldD != nil { + if *this.FieldD != *that1.FieldD { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", *this.FieldD, *that1.FieldD) + } + } else if this.FieldD != nil { + return fmt.Errorf("this.FieldD == nil && that.FieldD != nil") + } else if that1.FieldD != nil { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", this.FieldD, that1.FieldD) + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", *this.FieldE, *that1.FieldE) + } + } else if this.FieldE != nil { + return fmt.Errorf("this.FieldE == nil && that.FieldE != nil") + } else if that1.FieldE != nil { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", *this.FieldF, *that1.FieldF) + } + } else if this.FieldF != nil { + return fmt.Errorf("this.FieldF == nil && that.FieldF != nil") + } else if that1.FieldF != nil { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if this.FieldG != nil && that1.FieldG != nil { + if *this.FieldG != *that1.FieldG { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", *this.FieldG, *that1.FieldG) + } + } else if this.FieldG != nil { + return fmt.Errorf("this.FieldG == nil && that.FieldG != nil") + } else if that1.FieldG != nil { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", *this.FieldH, *that1.FieldH) + } + } else if this.FieldH != nil { + return fmt.Errorf("this.FieldH == nil && that.FieldH != nil") + } else if that1.FieldH != nil { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", *this.FieldI, *that1.FieldI) + } + } else if this.FieldI != nil { + return fmt.Errorf("this.FieldI == nil && that.FieldI != nil") + } else if that1.FieldI != nil { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if this.FieldJ != nil && that1.FieldJ != nil { + if *this.FieldJ != *that1.FieldJ { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", *this.FieldJ, *that1.FieldJ) + } + } else if this.FieldJ != nil { + return fmt.Errorf("this.FieldJ == nil && that.FieldJ != nil") + } else if that1.FieldJ != nil { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if this.FieldK != nil && that1.FieldK != nil { + if *this.FieldK != *that1.FieldK { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", *this.FieldK, *that1.FieldK) + } + } else if this.FieldK != nil { + return fmt.Errorf("this.FieldK == nil && that.FieldK != nil") + } else if that1.FieldK != nil { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", this.FieldK, that1.FieldK) + } + if this.FielL != nil && that1.FielL != nil { + if *this.FielL != *that1.FielL { + return fmt.Errorf("FielL this(%v) Not Equal that(%v)", *this.FielL, *that1.FielL) + } + } else if this.FielL != nil { + return fmt.Errorf("this.FielL == nil && that.FielL != nil") + } else if that1.FielL != nil { + return fmt.Errorf("FielL this(%v) Not Equal that(%v)", this.FielL, that1.FielL) + } + if this.FieldM != nil && that1.FieldM != nil { + if *this.FieldM != *that1.FieldM { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", *this.FieldM, *that1.FieldM) + } + } else if this.FieldM != nil { + return fmt.Errorf("this.FieldM == nil && that.FieldM != nil") + } else if that1.FieldM != nil { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", this.FieldM, that1.FieldM) + } + if this.FieldN != nil && that1.FieldN != nil { + if *this.FieldN != *that1.FieldN { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", *this.FieldN, *that1.FieldN) + } + } else if this.FieldN != nil { + return fmt.Errorf("this.FieldN == nil && that.FieldN != nil") + } else if that1.FieldN != nil { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", this.FieldN, that1.FieldN) + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", this.FieldO, that1.FieldO) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if this.FieldC != nil && that1.FieldC != nil { + if *this.FieldC != *that1.FieldC { + return false + } + } else if this.FieldC != nil { + return false + } else if that1.FieldC != nil { + return false + } + if this.FieldD != nil && that1.FieldD != nil { + if *this.FieldD != *that1.FieldD { + return false + } + } else if this.FieldD != nil { + return false + } else if that1.FieldD != nil { + return false + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return false + } + } else if this.FieldE != nil { + return false + } else if that1.FieldE != nil { + return false + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return false + } + } else if this.FieldF != nil { + return false + } else if that1.FieldF != nil { + return false + } + if this.FieldG != nil && that1.FieldG != nil { + if *this.FieldG != *that1.FieldG { + return false + } + } else if this.FieldG != nil { + return false + } else if that1.FieldG != nil { + return false + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return false + } + } else if this.FieldH != nil { + return false + } else if that1.FieldH != nil { + return false + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return false + } + } else if this.FieldI != nil { + return false + } else if that1.FieldI != nil { + return false + } + if this.FieldJ != nil && that1.FieldJ != nil { + if *this.FieldJ != *that1.FieldJ { + return false + } + } else if this.FieldJ != nil { + return false + } else if that1.FieldJ != nil { + return false + } + if this.FieldK != nil && that1.FieldK != nil { + if *this.FieldK != *that1.FieldK { + return false + } + } else if this.FieldK != nil { + return false + } else if that1.FieldK != nil { + return false + } + if this.FielL != nil && that1.FielL != nil { + if *this.FielL != *that1.FielL { + return false + } + } else if this.FielL != nil { + return false + } else if that1.FielL != nil { + return false + } + if this.FieldM != nil && that1.FieldM != nil { + if *this.FieldM != *that1.FieldM { + return false + } + } else if this.FieldM != nil { + return false + } else if that1.FieldM != nil { + return false + } + if this.FieldN != nil && that1.FieldN != nil { + if *this.FieldN != *that1.FieldN { + return false + } + } else if this.FieldN != nil { + return false + } else if that1.FieldN != nil { + return false + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinRepNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinRepNativebut is not nil && this == nil") + } + if len(this.FieldA) != len(that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", len(this.FieldA), len(that1.FieldA)) + } + for i := range this.FieldA { + if this.FieldA[i] != that1.FieldA[i] { + return fmt.Errorf("FieldA this[%v](%v) Not Equal that[%v](%v)", i, this.FieldA[i], i, that1.FieldA[i]) + } + } + if len(this.FieldB) != len(that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", len(this.FieldB), len(that1.FieldB)) + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return fmt.Errorf("FieldB this[%v](%v) Not Equal that[%v](%v)", i, this.FieldB[i], i, that1.FieldB[i]) + } + } + if len(this.FieldC) != len(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", len(this.FieldC), len(that1.FieldC)) + } + for i := range this.FieldC { + if this.FieldC[i] != that1.FieldC[i] { + return fmt.Errorf("FieldC this[%v](%v) Not Equal that[%v](%v)", i, this.FieldC[i], i, that1.FieldC[i]) + } + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if this.FieldD[i] != that1.FieldD[i] { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if len(this.FieldE) != len(that1.FieldE) { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", len(this.FieldE), len(that1.FieldE)) + } + for i := range this.FieldE { + if this.FieldE[i] != that1.FieldE[i] { + return fmt.Errorf("FieldE this[%v](%v) Not Equal that[%v](%v)", i, this.FieldE[i], i, that1.FieldE[i]) + } + } + if len(this.FieldF) != len(that1.FieldF) { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", len(this.FieldF), len(that1.FieldF)) + } + for i := range this.FieldF { + if this.FieldF[i] != that1.FieldF[i] { + return fmt.Errorf("FieldF this[%v](%v) Not Equal that[%v](%v)", i, this.FieldF[i], i, that1.FieldF[i]) + } + } + if len(this.FieldG) != len(that1.FieldG) { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", len(this.FieldG), len(that1.FieldG)) + } + for i := range this.FieldG { + if this.FieldG[i] != that1.FieldG[i] { + return fmt.Errorf("FieldG this[%v](%v) Not Equal that[%v](%v)", i, this.FieldG[i], i, that1.FieldG[i]) + } + } + if len(this.FieldH) != len(that1.FieldH) { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", len(this.FieldH), len(that1.FieldH)) + } + for i := range this.FieldH { + if this.FieldH[i] != that1.FieldH[i] { + return fmt.Errorf("FieldH this[%v](%v) Not Equal that[%v](%v)", i, this.FieldH[i], i, that1.FieldH[i]) + } + } + if len(this.FieldI) != len(that1.FieldI) { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", len(this.FieldI), len(that1.FieldI)) + } + for i := range this.FieldI { + if this.FieldI[i] != that1.FieldI[i] { + return fmt.Errorf("FieldI this[%v](%v) Not Equal that[%v](%v)", i, this.FieldI[i], i, that1.FieldI[i]) + } + } + if len(this.FieldJ) != len(that1.FieldJ) { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", len(this.FieldJ), len(that1.FieldJ)) + } + for i := range this.FieldJ { + if this.FieldJ[i] != that1.FieldJ[i] { + return fmt.Errorf("FieldJ this[%v](%v) Not Equal that[%v](%v)", i, this.FieldJ[i], i, that1.FieldJ[i]) + } + } + if len(this.FieldK) != len(that1.FieldK) { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", len(this.FieldK), len(that1.FieldK)) + } + for i := range this.FieldK { + if this.FieldK[i] != that1.FieldK[i] { + return fmt.Errorf("FieldK this[%v](%v) Not Equal that[%v](%v)", i, this.FieldK[i], i, that1.FieldK[i]) + } + } + if len(this.FieldL) != len(that1.FieldL) { + return fmt.Errorf("FieldL this(%v) Not Equal that(%v)", len(this.FieldL), len(that1.FieldL)) + } + for i := range this.FieldL { + if this.FieldL[i] != that1.FieldL[i] { + return fmt.Errorf("FieldL this[%v](%v) Not Equal that[%v](%v)", i, this.FieldL[i], i, that1.FieldL[i]) + } + } + if len(this.FieldM) != len(that1.FieldM) { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", len(this.FieldM), len(that1.FieldM)) + } + for i := range this.FieldM { + if this.FieldM[i] != that1.FieldM[i] { + return fmt.Errorf("FieldM this[%v](%v) Not Equal that[%v](%v)", i, this.FieldM[i], i, that1.FieldM[i]) + } + } + if len(this.FieldN) != len(that1.FieldN) { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", len(this.FieldN), len(that1.FieldN)) + } + for i := range this.FieldN { + if this.FieldN[i] != that1.FieldN[i] { + return fmt.Errorf("FieldN this[%v](%v) Not Equal that[%v](%v)", i, this.FieldN[i], i, that1.FieldN[i]) + } + } + if len(this.FieldO) != len(that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", len(this.FieldO), len(that1.FieldO)) + } + for i := range this.FieldO { + if !bytes.Equal(this.FieldO[i], that1.FieldO[i]) { + return fmt.Errorf("FieldO this[%v](%v) Not Equal that[%v](%v)", i, this.FieldO[i], i, that1.FieldO[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.FieldA) != len(that1.FieldA) { + return false + } + for i := range this.FieldA { + if this.FieldA[i] != that1.FieldA[i] { + return false + } + } + if len(this.FieldB) != len(that1.FieldB) { + return false + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return false + } + } + if len(this.FieldC) != len(that1.FieldC) { + return false + } + for i := range this.FieldC { + if this.FieldC[i] != that1.FieldC[i] { + return false + } + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if this.FieldD[i] != that1.FieldD[i] { + return false + } + } + if len(this.FieldE) != len(that1.FieldE) { + return false + } + for i := range this.FieldE { + if this.FieldE[i] != that1.FieldE[i] { + return false + } + } + if len(this.FieldF) != len(that1.FieldF) { + return false + } + for i := range this.FieldF { + if this.FieldF[i] != that1.FieldF[i] { + return false + } + } + if len(this.FieldG) != len(that1.FieldG) { + return false + } + for i := range this.FieldG { + if this.FieldG[i] != that1.FieldG[i] { + return false + } + } + if len(this.FieldH) != len(that1.FieldH) { + return false + } + for i := range this.FieldH { + if this.FieldH[i] != that1.FieldH[i] { + return false + } + } + if len(this.FieldI) != len(that1.FieldI) { + return false + } + for i := range this.FieldI { + if this.FieldI[i] != that1.FieldI[i] { + return false + } + } + if len(this.FieldJ) != len(that1.FieldJ) { + return false + } + for i := range this.FieldJ { + if this.FieldJ[i] != that1.FieldJ[i] { + return false + } + } + if len(this.FieldK) != len(that1.FieldK) { + return false + } + for i := range this.FieldK { + if this.FieldK[i] != that1.FieldK[i] { + return false + } + } + if len(this.FieldL) != len(that1.FieldL) { + return false + } + for i := range this.FieldL { + if this.FieldL[i] != that1.FieldL[i] { + return false + } + } + if len(this.FieldM) != len(that1.FieldM) { + return false + } + for i := range this.FieldM { + if this.FieldM[i] != that1.FieldM[i] { + return false + } + } + if len(this.FieldN) != len(that1.FieldN) { + return false + } + for i := range this.FieldN { + if this.FieldN[i] != that1.FieldN[i] { + return false + } + } + if len(this.FieldO) != len(that1.FieldO) { + return false + } + for i := range this.FieldO { + if !bytes.Equal(this.FieldO[i], that1.FieldO[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinStruct) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinStructbut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if !this.FieldC.Equal(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", *this.FieldE, *that1.FieldE) + } + } else if this.FieldE != nil { + return fmt.Errorf("this.FieldE == nil && that.FieldE != nil") + } else if that1.FieldE != nil { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", *this.FieldF, *that1.FieldF) + } + } else if this.FieldF != nil { + return fmt.Errorf("this.FieldF == nil && that.FieldF != nil") + } else if that1.FieldF != nil { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if !this.FieldG.Equal(that1.FieldG) { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", *this.FieldH, *that1.FieldH) + } + } else if this.FieldH != nil { + return fmt.Errorf("this.FieldH == nil && that.FieldH != nil") + } else if that1.FieldH != nil { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", *this.FieldI, *that1.FieldI) + } + } else if this.FieldI != nil { + return fmt.Errorf("this.FieldI == nil && that.FieldI != nil") + } else if that1.FieldI != nil { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if !bytes.Equal(this.FieldJ, that1.FieldJ) { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if !this.FieldC.Equal(that1.FieldC) { + return false + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return false + } + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return false + } + } else if this.FieldE != nil { + return false + } else if that1.FieldE != nil { + return false + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return false + } + } else if this.FieldF != nil { + return false + } else if that1.FieldF != nil { + return false + } + if !this.FieldG.Equal(that1.FieldG) { + return false + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return false + } + } else if this.FieldH != nil { + return false + } else if that1.FieldH != nil { + return false + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return false + } + } else if this.FieldI != nil { + return false + } else if that1.FieldI != nil { + return false + } + if !bytes.Equal(this.FieldJ, that1.FieldJ) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameCustomType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameCustomType) + if !ok { + return fmt.Errorf("that is not of type *CustomNameCustomType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameCustomType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameCustomTypebut is not nil && this == nil") + } + if that1.FieldA == nil { + if this.FieldA != nil { + return fmt.Errorf("this.FieldA != nil && that1.FieldA == nil") + } + } else if !this.FieldA.Equal(*that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if that1.FieldB == nil { + if this.FieldB != nil { + return fmt.Errorf("this.FieldB != nil && that1.FieldB == nil") + } + } else if !this.FieldB.Equal(*that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if len(this.FieldC) != len(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", len(this.FieldC), len(that1.FieldC)) + } + for i := range this.FieldC { + if !this.FieldC[i].Equal(that1.FieldC[i]) { + return fmt.Errorf("FieldC this[%v](%v) Not Equal that[%v](%v)", i, this.FieldC[i], i, that1.FieldC[i]) + } + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameCustomType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameCustomType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.FieldA == nil { + if this.FieldA != nil { + return false + } + } else if !this.FieldA.Equal(*that1.FieldA) { + return false + } + if that1.FieldB == nil { + if this.FieldB != nil { + return false + } + } else if !this.FieldB.Equal(*that1.FieldB) { + return false + } + if len(this.FieldC) != len(that1.FieldC) { + return false + } + for i := range this.FieldC { + if !this.FieldC[i].Equal(that1.FieldC[i]) { + return false + } + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinEmbeddedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinEmbeddedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinEmbeddedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinEmbeddedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinEmbeddedStructUnionbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.FieldA.Equal(that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinEmbeddedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinEmbeddedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.FieldA.Equal(that1.FieldA) { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameEnum) + if !ok { + return fmt.Errorf("that is not of type *CustomNameEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameEnumbut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if len(this.FieldB) != len(that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", len(this.FieldB), len(that1.FieldB)) + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return fmt.Errorf("FieldB this[%v](%v) Not Equal that[%v](%v)", i, this.FieldB[i], i, that1.FieldB[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if len(this.FieldB) != len(that1.FieldB) { + return false + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NoExtensionsMap) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NoExtensionsMap) + if !ok { + return fmt.Errorf("that is not of type *NoExtensionsMap") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NoExtensionsMap but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NoExtensionsMapbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) { + return fmt.Errorf("XXX_extensions this(%v) Not Equal that(%v)", this.XXX_extensions, that1.XXX_extensions) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NoExtensionsMap) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NoExtensionsMap) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Unrecognized) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Unrecognized) + if !ok { + return fmt.Errorf("that is not of type *Unrecognized") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Unrecognized but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Unrecognizedbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *Unrecognized) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Unrecognized) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} +func (this *UnrecognizedWithInner) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithInner) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithInner") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithInner but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithInnerbut is not nil && this == nil") + } + if len(this.Embedded) != len(that1.Embedded) { + return fmt.Errorf("Embedded this(%v) Not Equal that(%v)", len(this.Embedded), len(that1.Embedded)) + } + for i := range this.Embedded { + if !this.Embedded[i].Equal(that1.Embedded[i]) { + return fmt.Errorf("Embedded this[%v](%v) Not Equal that[%v](%v)", i, this.Embedded[i], i, that1.Embedded[i]) + } + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *UnrecognizedWithInner) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithInner) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Embedded) != len(that1.Embedded) { + return false + } + for i := range this.Embedded { + if !this.Embedded[i].Equal(that1.Embedded[i]) { + return false + } + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *UnrecognizedWithInner_Inner) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithInner_Inner) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithInner_Inner") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithInner_Inner but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithInner_Innerbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *UnrecognizedWithInner_Inner) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithInner_Inner) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} +func (this *UnrecognizedWithEmbed) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithEmbed) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithEmbed") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithEmbed but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithEmbedbut is not nil && this == nil") + } + if !this.UnrecognizedWithEmbed_Embedded.Equal(&that1.UnrecognizedWithEmbed_Embedded) { + return fmt.Errorf("UnrecognizedWithEmbed_Embedded this(%v) Not Equal that(%v)", this.UnrecognizedWithEmbed_Embedded, that1.UnrecognizedWithEmbed_Embedded) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *UnrecognizedWithEmbed) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithEmbed) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.UnrecognizedWithEmbed_Embedded.Equal(&that1.UnrecognizedWithEmbed_Embedded) { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *UnrecognizedWithEmbed_Embedded) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithEmbed_Embedded) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithEmbed_Embedded") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithEmbed_Embedded but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithEmbed_Embeddedbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *UnrecognizedWithEmbed_Embedded) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithEmbed_Embedded) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} + +type NidOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() float64 + GetField2() float32 + GetField3() int32 + GetField4() int64 + GetField5() uint32 + GetField6() uint64 + GetField7() int32 + GetField8() int64 + GetField9() uint32 + GetField10() int32 + GetField11() uint64 + GetField12() int64 + GetField13() bool + GetField14() string + GetField15() []byte +} + +func (this *NidOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptNativeFromFace(this) +} + +func (this *NidOptNative) GetField1() float64 { + return this.Field1 +} + +func (this *NidOptNative) GetField2() float32 { + return this.Field2 +} + +func (this *NidOptNative) GetField3() int32 { + return this.Field3 +} + +func (this *NidOptNative) GetField4() int64 { + return this.Field4 +} + +func (this *NidOptNative) GetField5() uint32 { + return this.Field5 +} + +func (this *NidOptNative) GetField6() uint64 { + return this.Field6 +} + +func (this *NidOptNative) GetField7() int32 { + return this.Field7 +} + +func (this *NidOptNative) GetField8() int64 { + return this.Field8 +} + +func (this *NidOptNative) GetField9() uint32 { + return this.Field9 +} + +func (this *NidOptNative) GetField10() int32 { + return this.Field10 +} + +func (this *NidOptNative) GetField11() uint64 { + return this.Field11 +} + +func (this *NidOptNative) GetField12() int64 { + return this.Field12 +} + +func (this *NidOptNative) GetField13() bool { + return this.Field13 +} + +func (this *NidOptNative) GetField14() string { + return this.Field14 +} + +func (this *NidOptNative) GetField15() []byte { + return this.Field15 +} + +func NewNidOptNativeFromFace(that NidOptNativeFace) *NidOptNative { + this := &NidOptNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *int32 + GetField4() *int64 + GetField5() *uint32 + GetField6() *uint64 + GetField7() *int32 + GetField8() *int64 + GetField9() *uint32 + GetField10() *int32 + GetField11() *uint64 + GetField12() *int64 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptNativeFromFace(this) +} + +func (this *NinOptNative) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptNative) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptNative) GetField3() *int32 { + return this.Field3 +} + +func (this *NinOptNative) GetField4() *int64 { + return this.Field4 +} + +func (this *NinOptNative) GetField5() *uint32 { + return this.Field5 +} + +func (this *NinOptNative) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptNative) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptNative) GetField8() *int64 { + return this.Field8 +} + +func (this *NinOptNative) GetField9() *uint32 { + return this.Field9 +} + +func (this *NinOptNative) GetField10() *int32 { + return this.Field10 +} + +func (this *NinOptNative) GetField11() *uint64 { + return this.Field11 +} + +func (this *NinOptNative) GetField12() *int64 { + return this.Field12 +} + +func (this *NinOptNative) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptNative) GetField14() *string { + return this.Field14 +} + +func (this *NinOptNative) GetField15() []byte { + return this.Field15 +} + +func NewNinOptNativeFromFace(that NinOptNativeFace) *NinOptNative { + this := &NinOptNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NidRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepNativeFromFace(this) +} + +func (this *NidRepNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NidRepNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NidRepNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NidRepNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NidRepNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NidRepNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NidRepNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NidRepNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NidRepNative) GetField13() []bool { + return this.Field13 +} + +func (this *NidRepNative) GetField14() []string { + return this.Field14 +} + +func (this *NidRepNative) GetField15() [][]byte { + return this.Field15 +} + +func NewNidRepNativeFromFace(that NidRepNativeFace) *NidRepNative { + this := &NidRepNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NinRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepNativeFromFace(this) +} + +func (this *NinRepNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NinRepNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NinRepNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NinRepNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NinRepNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NinRepNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NinRepNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NinRepNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NinRepNative) GetField13() []bool { + return this.Field13 +} + +func (this *NinRepNative) GetField14() []string { + return this.Field14 +} + +func (this *NinRepNative) GetField15() [][]byte { + return this.Field15 +} + +func NewNinRepNativeFromFace(that NinRepNativeFace) *NinRepNative { + this := &NinRepNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepPackedNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool +} + +func (this *NidRepPackedNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepPackedNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepPackedNativeFromFace(this) +} + +func (this *NidRepPackedNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepPackedNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepPackedNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NidRepPackedNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NidRepPackedNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NidRepPackedNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepPackedNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepPackedNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NidRepPackedNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NidRepPackedNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NidRepPackedNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NidRepPackedNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NidRepPackedNative) GetField13() []bool { + return this.Field13 +} + +func NewNidRepPackedNativeFromFace(that NidRepPackedNativeFace) *NidRepPackedNative { + this := &NidRepPackedNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + return this +} + +type NinRepPackedNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool +} + +func (this *NinRepPackedNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepPackedNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepPackedNativeFromFace(this) +} + +func (this *NinRepPackedNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepPackedNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepPackedNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NinRepPackedNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NinRepPackedNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NinRepPackedNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepPackedNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepPackedNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NinRepPackedNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NinRepPackedNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NinRepPackedNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NinRepPackedNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NinRepPackedNative) GetField13() []bool { + return this.Field13 +} + +func NewNinRepPackedNativeFromFace(that NinRepPackedNativeFace) *NinRepPackedNative { + this := &NinRepPackedNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + return this +} + +type NidOptStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() float64 + GetField2() float32 + GetField3() NidOptNative + GetField4() NinOptNative + GetField6() uint64 + GetField7() int32 + GetField8() NidOptNative + GetField13() bool + GetField14() string + GetField15() []byte +} + +func (this *NidOptStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptStructFromFace(this) +} + +func (this *NidOptStruct) GetField1() float64 { + return this.Field1 +} + +func (this *NidOptStruct) GetField2() float32 { + return this.Field2 +} + +func (this *NidOptStruct) GetField3() NidOptNative { + return this.Field3 +} + +func (this *NidOptStruct) GetField4() NinOptNative { + return this.Field4 +} + +func (this *NidOptStruct) GetField6() uint64 { + return this.Field6 +} + +func (this *NidOptStruct) GetField7() int32 { + return this.Field7 +} + +func (this *NidOptStruct) GetField8() NidOptNative { + return this.Field8 +} + +func (this *NidOptStruct) GetField13() bool { + return this.Field13 +} + +func (this *NidOptStruct) GetField14() string { + return this.Field14 +} + +func (this *NidOptStruct) GetField15() []byte { + return this.Field15 +} + +func NewNidOptStructFromFace(that NidOptStructFace) *NidOptStruct { + this := &NidOptStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *NidOptNative + GetField4() *NinOptNative + GetField6() *uint64 + GetField7() *int32 + GetField8() *NidOptNative + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptStructFromFace(this) +} + +func (this *NinOptStruct) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptStruct) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptStruct) GetField3() *NidOptNative { + return this.Field3 +} + +func (this *NinOptStruct) GetField4() *NinOptNative { + return this.Field4 +} + +func (this *NinOptStruct) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptStruct) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptStruct) GetField8() *NidOptNative { + return this.Field8 +} + +func (this *NinOptStruct) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptStruct) GetField14() *string { + return this.Field14 +} + +func (this *NinOptStruct) GetField15() []byte { + return this.Field15 +} + +func NewNinOptStructFromFace(that NinOptStructFace) *NinOptStruct { + this := &NinOptStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []NidOptNative + GetField4() []NinOptNative + GetField6() []uint64 + GetField7() []int32 + GetField8() []NidOptNative + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NidRepStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepStructFromFace(this) +} + +func (this *NidRepStruct) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepStruct) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepStruct) GetField3() []NidOptNative { + return this.Field3 +} + +func (this *NidRepStruct) GetField4() []NinOptNative { + return this.Field4 +} + +func (this *NidRepStruct) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepStruct) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepStruct) GetField8() []NidOptNative { + return this.Field8 +} + +func (this *NidRepStruct) GetField13() []bool { + return this.Field13 +} + +func (this *NidRepStruct) GetField14() []string { + return this.Field14 +} + +func (this *NidRepStruct) GetField15() [][]byte { + return this.Field15 +} + +func NewNidRepStructFromFace(that NidRepStructFace) *NidRepStruct { + this := &NidRepStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinRepStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []*NidOptNative + GetField4() []*NinOptNative + GetField6() []uint64 + GetField7() []int32 + GetField8() []*NidOptNative + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NinRepStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepStructFromFace(this) +} + +func (this *NinRepStruct) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepStruct) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepStruct) GetField3() []*NidOptNative { + return this.Field3 +} + +func (this *NinRepStruct) GetField4() []*NinOptNative { + return this.Field4 +} + +func (this *NinRepStruct) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepStruct) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepStruct) GetField8() []*NidOptNative { + return this.Field8 +} + +func (this *NinRepStruct) GetField13() []bool { + return this.Field13 +} + +func (this *NinRepStruct) GetField14() []string { + return this.Field14 +} + +func (this *NinRepStruct) GetField15() [][]byte { + return this.Field15 +} + +func NewNinRepStructFromFace(that NinRepStructFace) *NinRepStruct { + this := &NinRepStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidEmbeddedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() NidOptNative + GetField210() bool +} + +func (this *NidEmbeddedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidEmbeddedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidEmbeddedStructFromFace(this) +} + +func (this *NidEmbeddedStruct) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NidEmbeddedStruct) GetField200() NidOptNative { + return this.Field200 +} + +func (this *NidEmbeddedStruct) GetField210() bool { + return this.Field210 +} + +func NewNidEmbeddedStructFromFace(that NidEmbeddedStructFace) *NidEmbeddedStruct { + this := &NidEmbeddedStruct{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NinEmbeddedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() *NidOptNative + GetField210() *bool +} + +func (this *NinEmbeddedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinEmbeddedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinEmbeddedStructFromFace(this) +} + +func (this *NinEmbeddedStruct) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NinEmbeddedStruct) GetField200() *NidOptNative { + return this.Field200 +} + +func (this *NinEmbeddedStruct) GetField210() *bool { + return this.Field210 +} + +func NewNinEmbeddedStructFromFace(that NinEmbeddedStructFace) *NinEmbeddedStruct { + this := &NinEmbeddedStruct{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NidNestedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() NidOptStruct + GetField2() []NidRepStruct +} + +func (this *NidNestedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidNestedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidNestedStructFromFace(this) +} + +func (this *NidNestedStruct) GetField1() NidOptStruct { + return this.Field1 +} + +func (this *NidNestedStruct) GetField2() []NidRepStruct { + return this.Field2 +} + +func NewNidNestedStructFromFace(that NidNestedStructFace) *NidNestedStruct { + this := &NidNestedStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + return this +} + +type NinNestedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *NinOptStruct + GetField2() []*NinRepStruct +} + +func (this *NinNestedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinNestedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinNestedStructFromFace(this) +} + +func (this *NinNestedStruct) GetField1() *NinOptStruct { + return this.Field1 +} + +func (this *NinNestedStruct) GetField2() []*NinRepStruct { + return this.Field2 +} + +func NewNinNestedStructFromFace(that NinNestedStructFace) *NinNestedStruct { + this := &NinNestedStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + return this +} + +type NidOptCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() Uuid + GetValue() github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NidOptCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptCustomFromFace(this) +} + +func (this *NidOptCustom) GetId() Uuid { + return this.Id +} + +func (this *NidOptCustom) GetValue() github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNidOptCustomFromFace(that NidOptCustomFace) *NidOptCustom { + this := &NidOptCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type CustomDashFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetValue() *github_com_gogo_protobuf_test_custom_dash_type.Bytes +} + +func (this *CustomDash) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomDash) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomDashFromFace(this) +} + +func (this *CustomDash) GetValue() *github_com_gogo_protobuf_test_custom_dash_type.Bytes { + return this.Value +} + +func NewCustomDashFromFace(that CustomDashFace) *CustomDash { + this := &CustomDash{} + this.Value = that.GetValue() + return this +} + +type NinOptCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() *Uuid + GetValue() *github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NinOptCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptCustomFromFace(this) +} + +func (this *NinOptCustom) GetId() *Uuid { + return this.Id +} + +func (this *NinOptCustom) GetValue() *github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNinOptCustomFromFace(that NinOptCustomFace) *NinOptCustom { + this := &NinOptCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NidRepCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() []Uuid + GetValue() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NidRepCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepCustomFromFace(this) +} + +func (this *NidRepCustom) GetId() []Uuid { + return this.Id +} + +func (this *NidRepCustom) GetValue() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNidRepCustomFromFace(that NidRepCustomFace) *NidRepCustom { + this := &NidRepCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NinRepCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() []Uuid + GetValue() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NinRepCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepCustomFromFace(this) +} + +func (this *NinRepCustom) GetId() []Uuid { + return this.Id +} + +func (this *NinRepCustom) GetValue() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNinRepCustomFromFace(that NinRepCustomFace) *NinRepCustom { + this := &NinRepCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NinOptNativeUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *int32 + GetField4() *int64 + GetField5() *uint32 + GetField6() *uint64 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptNativeUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptNativeUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptNativeUnionFromFace(this) +} + +func (this *NinOptNativeUnion) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptNativeUnion) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptNativeUnion) GetField3() *int32 { + return this.Field3 +} + +func (this *NinOptNativeUnion) GetField4() *int64 { + return this.Field4 +} + +func (this *NinOptNativeUnion) GetField5() *uint32 { + return this.Field5 +} + +func (this *NinOptNativeUnion) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptNativeUnion) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptNativeUnion) GetField14() *string { + return this.Field14 +} + +func (this *NinOptNativeUnion) GetField15() []byte { + return this.Field15 +} + +func NewNinOptNativeUnionFromFace(that NinOptNativeUnionFace) *NinOptNativeUnion { + this := &NinOptNativeUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *NidOptNative + GetField4() *NinOptNative + GetField6() *uint64 + GetField7() *int32 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptStructUnionFromFace(this) +} + +func (this *NinOptStructUnion) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptStructUnion) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptStructUnion) GetField3() *NidOptNative { + return this.Field3 +} + +func (this *NinOptStructUnion) GetField4() *NinOptNative { + return this.Field4 +} + +func (this *NinOptStructUnion) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptStructUnion) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptStructUnion) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptStructUnion) GetField14() *string { + return this.Field14 +} + +func (this *NinOptStructUnion) GetField15() []byte { + return this.Field15 +} + +func NewNinOptStructUnionFromFace(that NinOptStructUnionFace) *NinOptStructUnion { + this := &NinOptStructUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinEmbeddedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() *NinOptNative + GetField210() *bool +} + +func (this *NinEmbeddedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinEmbeddedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinEmbeddedStructUnionFromFace(this) +} + +func (this *NinEmbeddedStructUnion) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NinEmbeddedStructUnion) GetField200() *NinOptNative { + return this.Field200 +} + +func (this *NinEmbeddedStructUnion) GetField210() *bool { + return this.Field210 +} + +func NewNinEmbeddedStructUnionFromFace(that NinEmbeddedStructUnionFace) *NinEmbeddedStructUnion { + this := &NinEmbeddedStructUnion{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NinNestedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *NinOptNativeUnion + GetField2() *NinOptStructUnion + GetField3() *NinEmbeddedStructUnion +} + +func (this *NinNestedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinNestedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinNestedStructUnionFromFace(this) +} + +func (this *NinNestedStructUnion) GetField1() *NinOptNativeUnion { + return this.Field1 +} + +func (this *NinNestedStructUnion) GetField2() *NinOptStructUnion { + return this.Field2 +} + +func (this *NinNestedStructUnion) GetField3() *NinEmbeddedStructUnion { + return this.Field3 +} + +func NewNinNestedStructUnionFromFace(that NinNestedStructUnionFace) *NinNestedStructUnion { + this := &NinNestedStructUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + return this +} + +type TreeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetOr() *OrBranch + GetAnd() *AndBranch + GetLeaf() *Leaf +} + +func (this *Tree) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Tree) TestProto() github_com_gogo_protobuf_proto.Message { + return NewTreeFromFace(this) +} + +func (this *Tree) GetOr() *OrBranch { + return this.Or +} + +func (this *Tree) GetAnd() *AndBranch { + return this.And +} + +func (this *Tree) GetLeaf() *Leaf { + return this.Leaf +} + +func NewTreeFromFace(that TreeFace) *Tree { + this := &Tree{} + this.Or = that.GetOr() + this.And = that.GetAnd() + this.Leaf = that.GetLeaf() + return this +} + +type OrBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() Tree + GetRight() Tree +} + +func (this *OrBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *OrBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewOrBranchFromFace(this) +} + +func (this *OrBranch) GetLeft() Tree { + return this.Left +} + +func (this *OrBranch) GetRight() Tree { + return this.Right +} + +func NewOrBranchFromFace(that OrBranchFace) *OrBranch { + this := &OrBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type AndBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() Tree + GetRight() Tree +} + +func (this *AndBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AndBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAndBranchFromFace(this) +} + +func (this *AndBranch) GetLeft() Tree { + return this.Left +} + +func (this *AndBranch) GetRight() Tree { + return this.Right +} + +func NewAndBranchFromFace(that AndBranchFace) *AndBranch { + this := &AndBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type LeafFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetValue() int64 + GetStrValue() string +} + +func (this *Leaf) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Leaf) TestProto() github_com_gogo_protobuf_proto.Message { + return NewLeafFromFace(this) +} + +func (this *Leaf) GetValue() int64 { + return this.Value +} + +func (this *Leaf) GetStrValue() string { + return this.StrValue +} + +func NewLeafFromFace(that LeafFace) *Leaf { + this := &Leaf{} + this.Value = that.GetValue() + this.StrValue = that.GetStrValue() + return this +} + +type DeepTreeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetDown() *ADeepBranch + GetAnd() *AndDeepBranch + GetLeaf() *DeepLeaf +} + +func (this *DeepTree) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *DeepTree) TestProto() github_com_gogo_protobuf_proto.Message { + return NewDeepTreeFromFace(this) +} + +func (this *DeepTree) GetDown() *ADeepBranch { + return this.Down +} + +func (this *DeepTree) GetAnd() *AndDeepBranch { + return this.And +} + +func (this *DeepTree) GetLeaf() *DeepLeaf { + return this.Leaf +} + +func NewDeepTreeFromFace(that DeepTreeFace) *DeepTree { + this := &DeepTree{} + this.Down = that.GetDown() + this.And = that.GetAnd() + this.Leaf = that.GetLeaf() + return this +} + +type ADeepBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetDown() DeepTree +} + +func (this *ADeepBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *ADeepBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewADeepBranchFromFace(this) +} + +func (this *ADeepBranch) GetDown() DeepTree { + return this.Down +} + +func NewADeepBranchFromFace(that ADeepBranchFace) *ADeepBranch { + this := &ADeepBranch{} + this.Down = that.GetDown() + return this +} + +type AndDeepBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() DeepTree + GetRight() DeepTree +} + +func (this *AndDeepBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AndDeepBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAndDeepBranchFromFace(this) +} + +func (this *AndDeepBranch) GetLeft() DeepTree { + return this.Left +} + +func (this *AndDeepBranch) GetRight() DeepTree { + return this.Right +} + +func NewAndDeepBranchFromFace(that AndDeepBranchFace) *AndDeepBranch { + this := &AndDeepBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type DeepLeafFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetTree() Tree +} + +func (this *DeepLeaf) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *DeepLeaf) TestProto() github_com_gogo_protobuf_proto.Message { + return NewDeepLeafFromFace(this) +} + +func (this *DeepLeaf) GetTree() Tree { + return this.Tree +} + +func NewDeepLeafFromFace(that DeepLeafFace) *DeepLeaf { + this := &DeepLeaf{} + this.Tree = that.GetTree() + return this +} + +type NilFace interface { + Proto() github_com_gogo_protobuf_proto.Message +} + +func (this *Nil) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Nil) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNilFromFace(this) +} + +func NewNilFromFace(that NilFace) *Nil { + this := &Nil{} + return this +} + +type NidOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() TheTestEnum +} + +func (this *NidOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptEnumFromFace(this) +} + +func (this *NidOptEnum) GetField1() TheTestEnum { + return this.Field1 +} + +func NewNidOptEnumFromFace(that NidOptEnumFace) *NidOptEnum { + this := &NidOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type NinOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *TheTestEnum +} + +func (this *NinOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptEnumFromFace(this) +} + +func (this *NinOptEnum) GetField1() *TheTestEnum { + return this.Field1 +} + +func NewNinOptEnumFromFace(that NinOptEnumFace) *NinOptEnum { + this := &NinOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type NidRepEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []TheTestEnum +} + +func (this *NidRepEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepEnumFromFace(this) +} + +func (this *NidRepEnum) GetField1() []TheTestEnum { + return this.Field1 +} + +func NewNidRepEnumFromFace(that NidRepEnumFace) *NidRepEnum { + this := &NidRepEnum{} + this.Field1 = that.GetField1() + return this +} + +type NinRepEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []TheTestEnum +} + +func (this *NinRepEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepEnumFromFace(this) +} + +func (this *NinRepEnum) GetField1() []TheTestEnum { + return this.Field1 +} + +func NewNinRepEnumFromFace(that NinRepEnumFace) *NinRepEnum { + this := &NinRepEnum{} + this.Field1 = that.GetField1() + return this +} + +type AnotherNinOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *AnotherTestEnum +} + +func (this *AnotherNinOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AnotherNinOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAnotherNinOptEnumFromFace(this) +} + +func (this *AnotherNinOptEnum) GetField1() *AnotherTestEnum { + return this.Field1 +} + +func NewAnotherNinOptEnumFromFace(that AnotherNinOptEnumFace) *AnotherNinOptEnum { + this := &AnotherNinOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type TimerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetTime1() int64 + GetTime2() int64 + GetData() []byte +} + +func (this *Timer) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Timer) TestProto() github_com_gogo_protobuf_proto.Message { + return NewTimerFromFace(this) +} + +func (this *Timer) GetTime1() int64 { + return this.Time1 +} + +func (this *Timer) GetTime2() int64 { + return this.Time2 +} + +func (this *Timer) GetData() []byte { + return this.Data +} + +func NewTimerFromFace(that TimerFace) *Timer { + this := &Timer{} + this.Time1 = that.GetTime1() + this.Time2 = that.GetTime2() + this.Data = that.GetData() + return this +} + +type NestedDefinitionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *int64 + GetEnumField() *NestedDefinition_NestedEnum + GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg + GetNM() *NestedDefinition_NestedMessage +} + +func (this *NestedDefinition) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinitionFromFace(this) +} + +func (this *NestedDefinition) GetField1() *int64 { + return this.Field1 +} + +func (this *NestedDefinition) GetEnumField() *NestedDefinition_NestedEnum { + return this.EnumField +} + +func (this *NestedDefinition) GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.NNM +} + +func (this *NestedDefinition) GetNM() *NestedDefinition_NestedMessage { + return this.NM +} + +func NewNestedDefinitionFromFace(that NestedDefinitionFace) *NestedDefinition { + this := &NestedDefinition{} + this.Field1 = that.GetField1() + this.EnumField = that.GetEnumField() + this.NNM = that.GetNNM() + this.NM = that.GetNM() + return this +} + +type NestedDefinition_NestedMessageFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNestedField1() *uint64 + GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg +} + +func (this *NestedDefinition_NestedMessage) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition_NestedMessage) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinition_NestedMessageFromFace(this) +} + +func (this *NestedDefinition_NestedMessage) GetNestedField1() *uint64 { + return this.NestedField1 +} + +func (this *NestedDefinition_NestedMessage) GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.NNM +} + +func NewNestedDefinition_NestedMessageFromFace(that NestedDefinition_NestedMessageFace) *NestedDefinition_NestedMessage { + this := &NestedDefinition_NestedMessage{} + this.NestedField1 = that.GetNestedField1() + this.NNM = that.GetNNM() + return this +} + +type NestedDefinition_NestedMessage_NestedNestedMsgFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNestedNestedField1() *string +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinition_NestedMessage_NestedNestedMsgFromFace(this) +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) GetNestedNestedField1() *string { + return this.NestedNestedField1 +} + +func NewNestedDefinition_NestedMessage_NestedNestedMsgFromFace(that NestedDefinition_NestedMessage_NestedNestedMsgFace) *NestedDefinition_NestedMessage_NestedNestedMsg { + this := &NestedDefinition_NestedMessage_NestedNestedMsg{} + this.NestedNestedField1 = that.GetNestedNestedField1() + return this +} + +type NestedScopeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetA() *NestedDefinition_NestedMessage_NestedNestedMsg + GetB() *NestedDefinition_NestedEnum + GetC() *NestedDefinition_NestedMessage +} + +func (this *NestedScope) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedScope) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedScopeFromFace(this) +} + +func (this *NestedScope) GetA() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.A +} + +func (this *NestedScope) GetB() *NestedDefinition_NestedEnum { + return this.B +} + +func (this *NestedScope) GetC() *NestedDefinition_NestedMessage { + return this.C +} + +func NewNestedScopeFromFace(that NestedScopeFace) *NestedScope { + this := &NestedScope{} + this.A = that.GetA() + this.B = that.GetB() + this.C = that.GetC() + return this +} + +type CustomContainerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetCustomStruct() NidOptCustom +} + +func (this *CustomContainer) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomContainer) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomContainerFromFace(this) +} + +func (this *CustomContainer) GetCustomStruct() NidOptCustom { + return this.CustomStruct +} + +func NewCustomContainerFromFace(that CustomContainerFace) *CustomContainer { + this := &CustomContainer{} + this.CustomStruct = that.GetCustomStruct() + return this +} + +type CustomNameNidOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() float64 + GetFieldB() float32 + GetFieldC() int32 + GetFieldD() int64 + GetFieldE() uint32 + GetFieldF() uint64 + GetFieldG() int32 + GetFieldH() int64 + GetFieldI() uint32 + GetFieldJ() int32 + GetFieldK() uint64 + GetFieldL() int64 + GetFieldM() bool + GetFieldN() string + GetFieldO() []byte +} + +func (this *CustomNameNidOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNidOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNidOptNativeFromFace(this) +} + +func (this *CustomNameNidOptNative) GetFieldA() float64 { + return this.FieldA +} + +func (this *CustomNameNidOptNative) GetFieldB() float32 { + return this.FieldB +} + +func (this *CustomNameNidOptNative) GetFieldC() int32 { + return this.FieldC +} + +func (this *CustomNameNidOptNative) GetFieldD() int64 { + return this.FieldD +} + +func (this *CustomNameNidOptNative) GetFieldE() uint32 { + return this.FieldE +} + +func (this *CustomNameNidOptNative) GetFieldF() uint64 { + return this.FieldF +} + +func (this *CustomNameNidOptNative) GetFieldG() int32 { + return this.FieldG +} + +func (this *CustomNameNidOptNative) GetFieldH() int64 { + return this.FieldH +} + +func (this *CustomNameNidOptNative) GetFieldI() uint32 { + return this.FieldI +} + +func (this *CustomNameNidOptNative) GetFieldJ() int32 { + return this.FieldJ +} + +func (this *CustomNameNidOptNative) GetFieldK() uint64 { + return this.FieldK +} + +func (this *CustomNameNidOptNative) GetFieldL() int64 { + return this.FieldL +} + +func (this *CustomNameNidOptNative) GetFieldM() bool { + return this.FieldM +} + +func (this *CustomNameNidOptNative) GetFieldN() string { + return this.FieldN +} + +func (this *CustomNameNidOptNative) GetFieldO() []byte { + return this.FieldO +} + +func NewCustomNameNidOptNativeFromFace(that CustomNameNidOptNativeFace) *CustomNameNidOptNative { + this := &CustomNameNidOptNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FieldL = that.GetFieldL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *float64 + GetFieldB() *float32 + GetFieldC() *int32 + GetFieldD() *int64 + GetFieldE() *uint32 + GetFieldF() *uint64 + GetFieldG() *int32 + GetFieldH() *int64 + GetFieldI() *uint32 + GetFieldJ() *int32 + GetFieldK() *uint64 + GetFielL() *int64 + GetFieldM() *bool + GetFieldN() *string + GetFieldO() []byte +} + +func (this *CustomNameNinOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinOptNativeFromFace(this) +} + +func (this *CustomNameNinOptNative) GetFieldA() *float64 { + return this.FieldA +} + +func (this *CustomNameNinOptNative) GetFieldB() *float32 { + return this.FieldB +} + +func (this *CustomNameNinOptNative) GetFieldC() *int32 { + return this.FieldC +} + +func (this *CustomNameNinOptNative) GetFieldD() *int64 { + return this.FieldD +} + +func (this *CustomNameNinOptNative) GetFieldE() *uint32 { + return this.FieldE +} + +func (this *CustomNameNinOptNative) GetFieldF() *uint64 { + return this.FieldF +} + +func (this *CustomNameNinOptNative) GetFieldG() *int32 { + return this.FieldG +} + +func (this *CustomNameNinOptNative) GetFieldH() *int64 { + return this.FieldH +} + +func (this *CustomNameNinOptNative) GetFieldI() *uint32 { + return this.FieldI +} + +func (this *CustomNameNinOptNative) GetFieldJ() *int32 { + return this.FieldJ +} + +func (this *CustomNameNinOptNative) GetFieldK() *uint64 { + return this.FieldK +} + +func (this *CustomNameNinOptNative) GetFielL() *int64 { + return this.FielL +} + +func (this *CustomNameNinOptNative) GetFieldM() *bool { + return this.FieldM +} + +func (this *CustomNameNinOptNative) GetFieldN() *string { + return this.FieldN +} + +func (this *CustomNameNinOptNative) GetFieldO() []byte { + return this.FieldO +} + +func NewCustomNameNinOptNativeFromFace(that CustomNameNinOptNativeFace) *CustomNameNinOptNative { + this := &CustomNameNinOptNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FielL = that.GetFielL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() []float64 + GetFieldB() []float32 + GetFieldC() []int32 + GetFieldD() []int64 + GetFieldE() []uint32 + GetFieldF() []uint64 + GetFieldG() []int32 + GetFieldH() []int64 + GetFieldI() []uint32 + GetFieldJ() []int32 + GetFieldK() []uint64 + GetFieldL() []int64 + GetFieldM() []bool + GetFieldN() []string + GetFieldO() [][]byte +} + +func (this *CustomNameNinRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinRepNativeFromFace(this) +} + +func (this *CustomNameNinRepNative) GetFieldA() []float64 { + return this.FieldA +} + +func (this *CustomNameNinRepNative) GetFieldB() []float32 { + return this.FieldB +} + +func (this *CustomNameNinRepNative) GetFieldC() []int32 { + return this.FieldC +} + +func (this *CustomNameNinRepNative) GetFieldD() []int64 { + return this.FieldD +} + +func (this *CustomNameNinRepNative) GetFieldE() []uint32 { + return this.FieldE +} + +func (this *CustomNameNinRepNative) GetFieldF() []uint64 { + return this.FieldF +} + +func (this *CustomNameNinRepNative) GetFieldG() []int32 { + return this.FieldG +} + +func (this *CustomNameNinRepNative) GetFieldH() []int64 { + return this.FieldH +} + +func (this *CustomNameNinRepNative) GetFieldI() []uint32 { + return this.FieldI +} + +func (this *CustomNameNinRepNative) GetFieldJ() []int32 { + return this.FieldJ +} + +func (this *CustomNameNinRepNative) GetFieldK() []uint64 { + return this.FieldK +} + +func (this *CustomNameNinRepNative) GetFieldL() []int64 { + return this.FieldL +} + +func (this *CustomNameNinRepNative) GetFieldM() []bool { + return this.FieldM +} + +func (this *CustomNameNinRepNative) GetFieldN() []string { + return this.FieldN +} + +func (this *CustomNameNinRepNative) GetFieldO() [][]byte { + return this.FieldO +} + +func NewCustomNameNinRepNativeFromFace(that CustomNameNinRepNativeFace) *CustomNameNinRepNative { + this := &CustomNameNinRepNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FieldL = that.GetFieldL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *float64 + GetFieldB() *float32 + GetFieldC() *NidOptNative + GetFieldD() []*NinOptNative + GetFieldE() *uint64 + GetFieldF() *int32 + GetFieldG() *NidOptNative + GetFieldH() *bool + GetFieldI() *string + GetFieldJ() []byte +} + +func (this *CustomNameNinStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinStructFromFace(this) +} + +func (this *CustomNameNinStruct) GetFieldA() *float64 { + return this.FieldA +} + +func (this *CustomNameNinStruct) GetFieldB() *float32 { + return this.FieldB +} + +func (this *CustomNameNinStruct) GetFieldC() *NidOptNative { + return this.FieldC +} + +func (this *CustomNameNinStruct) GetFieldD() []*NinOptNative { + return this.FieldD +} + +func (this *CustomNameNinStruct) GetFieldE() *uint64 { + return this.FieldE +} + +func (this *CustomNameNinStruct) GetFieldF() *int32 { + return this.FieldF +} + +func (this *CustomNameNinStruct) GetFieldG() *NidOptNative { + return this.FieldG +} + +func (this *CustomNameNinStruct) GetFieldH() *bool { + return this.FieldH +} + +func (this *CustomNameNinStruct) GetFieldI() *string { + return this.FieldI +} + +func (this *CustomNameNinStruct) GetFieldJ() []byte { + return this.FieldJ +} + +func NewCustomNameNinStructFromFace(that CustomNameNinStructFace) *CustomNameNinStruct { + this := &CustomNameNinStruct{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + return this +} + +type CustomNameCustomTypeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *Uuid + GetFieldB() *github_com_gogo_protobuf_test_custom.Uint128 + GetFieldC() []Uuid + GetFieldD() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *CustomNameCustomType) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameCustomType) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameCustomTypeFromFace(this) +} + +func (this *CustomNameCustomType) GetFieldA() *Uuid { + return this.FieldA +} + +func (this *CustomNameCustomType) GetFieldB() *github_com_gogo_protobuf_test_custom.Uint128 { + return this.FieldB +} + +func (this *CustomNameCustomType) GetFieldC() []Uuid { + return this.FieldC +} + +func (this *CustomNameCustomType) GetFieldD() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.FieldD +} + +func NewCustomNameCustomTypeFromFace(that CustomNameCustomTypeFace) *CustomNameCustomType { + this := &CustomNameCustomType{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + return this +} + +type CustomNameNinEmbeddedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetFieldA() *NinOptNative + GetFieldB() *bool +} + +func (this *CustomNameNinEmbeddedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinEmbeddedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinEmbeddedStructUnionFromFace(this) +} + +func (this *CustomNameNinEmbeddedStructUnion) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *CustomNameNinEmbeddedStructUnion) GetFieldA() *NinOptNative { + return this.FieldA +} + +func (this *CustomNameNinEmbeddedStructUnion) GetFieldB() *bool { + return this.FieldB +} + +func NewCustomNameNinEmbeddedStructUnionFromFace(that CustomNameNinEmbeddedStructUnionFace) *CustomNameNinEmbeddedStructUnion { + this := &CustomNameNinEmbeddedStructUnion{} + this.NidOptNative = that.GetNidOptNative() + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + return this +} + +type CustomNameEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *TheTestEnum + GetFieldB() []TheTestEnum +} + +func (this *CustomNameEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameEnumFromFace(this) +} + +func (this *CustomNameEnum) GetFieldA() *TheTestEnum { + return this.FieldA +} + +func (this *CustomNameEnum) GetFieldB() []TheTestEnum { + return this.FieldB +} + +func NewCustomNameEnumFromFace(that CustomNameEnumFace) *CustomNameEnum { + this := &CustomNameEnum{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + return this +} + +type UnrecognizedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *string +} + +func (this *Unrecognized) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Unrecognized) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedFromFace(this) +} + +func (this *Unrecognized) GetField1() *string { + return this.Field1 +} + +func NewUnrecognizedFromFace(that UnrecognizedFace) *Unrecognized { + this := &Unrecognized{} + this.Field1 = that.GetField1() + return this +} + +type UnrecognizedWithInnerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetEmbedded() []*UnrecognizedWithInner_Inner + GetField2() *string +} + +func (this *UnrecognizedWithInner) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithInner) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithInnerFromFace(this) +} + +func (this *UnrecognizedWithInner) GetEmbedded() []*UnrecognizedWithInner_Inner { + return this.Embedded +} + +func (this *UnrecognizedWithInner) GetField2() *string { + return this.Field2 +} + +func NewUnrecognizedWithInnerFromFace(that UnrecognizedWithInnerFace) *UnrecognizedWithInner { + this := &UnrecognizedWithInner{} + this.Embedded = that.GetEmbedded() + this.Field2 = that.GetField2() + return this +} + +type UnrecognizedWithInner_InnerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *uint32 +} + +func (this *UnrecognizedWithInner_Inner) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithInner_Inner) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithInner_InnerFromFace(this) +} + +func (this *UnrecognizedWithInner_Inner) GetField1() *uint32 { + return this.Field1 +} + +func NewUnrecognizedWithInner_InnerFromFace(that UnrecognizedWithInner_InnerFace) *UnrecognizedWithInner_Inner { + this := &UnrecognizedWithInner_Inner{} + this.Field1 = that.GetField1() + return this +} + +type UnrecognizedWithEmbedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetUnrecognizedWithEmbed_Embedded() UnrecognizedWithEmbed_Embedded + GetField2() *string +} + +func (this *UnrecognizedWithEmbed) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithEmbed) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithEmbedFromFace(this) +} + +func (this *UnrecognizedWithEmbed) GetUnrecognizedWithEmbed_Embedded() UnrecognizedWithEmbed_Embedded { + return this.UnrecognizedWithEmbed_Embedded +} + +func (this *UnrecognizedWithEmbed) GetField2() *string { + return this.Field2 +} + +func NewUnrecognizedWithEmbedFromFace(that UnrecognizedWithEmbedFace) *UnrecognizedWithEmbed { + this := &UnrecognizedWithEmbed{} + this.UnrecognizedWithEmbed_Embedded = that.GetUnrecognizedWithEmbed_Embedded() + this.Field2 = that.GetField2() + return this +} + +type UnrecognizedWithEmbed_EmbeddedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *uint32 +} + +func (this *UnrecognizedWithEmbed_Embedded) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithEmbed_Embedded) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithEmbed_EmbeddedFromFace(this) +} + +func (this *UnrecognizedWithEmbed_Embedded) GetField1() *uint32 { + return this.Field1 +} + +func NewUnrecognizedWithEmbed_EmbeddedFromFace(that UnrecognizedWithEmbed_EmbeddedFace) *UnrecognizedWithEmbed_Embedded { + this := &UnrecognizedWithEmbed_Embedded{} + this.Field1 = that.GetField1() + return this +} + +func (this *NidOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NidOptNative{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinOptNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+valueToGoStringThetest(this.Field8, "int64")+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+valueToGoStringThetest(this.Field9, "uint32")+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+valueToGoStringThetest(this.Field10, "int32")+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+valueToGoStringThetest(this.Field11, "uint64")+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+valueToGoStringThetest(this.Field12, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NidRepNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinRepNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepPackedNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 17) + s = append(s, "&test.NidRepPackedNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepPackedNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 17) + s = append(s, "&test.NinRepPackedNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NidOptStruct{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + s = append(s, "Field3: "+strings.Replace(this.Field3.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field4: "+strings.Replace(this.Field4.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + s = append(s, "Field8: "+strings.Replace(this.Field8.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NinOptStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NidRepStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+strings.Replace(fmt.Sprintf("%#v", this.Field3), `&`, ``, 1)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+strings.Replace(fmt.Sprintf("%#v", this.Field4), `&`, ``, 1)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+strings.Replace(fmt.Sprintf("%#v", this.Field8), `&`, ``, 1)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NinRepStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidEmbeddedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NidEmbeddedStruct{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + s = append(s, "Field200: "+strings.Replace(this.Field200.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field210: "+fmt.Sprintf("%#v", this.Field210)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinEmbeddedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinEmbeddedStruct{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.Field200 != nil { + s = append(s, "Field200: "+fmt.Sprintf("%#v", this.Field200)+",\n") + } + if this.Field210 != nil { + s = append(s, "Field210: "+valueToGoStringThetest(this.Field210, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidNestedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidNestedStruct{") + s = append(s, "Field1: "+strings.Replace(this.Field1.GoString(), `&`, ``, 1)+",\n") + if this.Field2 != nil { + s = append(s, "Field2: "+strings.Replace(fmt.Sprintf("%#v", this.Field2), `&`, ``, 1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinNestedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinNestedStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidOptCustom{") + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomDash) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.CustomDash{") + if this.Value != nil { + s = append(s, "Value: "+valueToGoStringThetest(this.Value, "github_com_gogo_protobuf_test_custom_dash_type.Bytes")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinOptCustom{") + if this.Id != nil { + s = append(s, "Id: "+valueToGoStringThetest(this.Id, "Uuid")+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+valueToGoStringThetest(this.Value, "github_com_gogo_protobuf_test_custom.Uint128")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidRepCustom{") + if this.Id != nil { + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinRepCustom{") + if this.Id != nil { + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNativeUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 13) + s = append(s, "&test.NinOptNativeUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 13) + s = append(s, "&test.NinOptStructUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinEmbeddedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinEmbeddedStructUnion{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.Field200 != nil { + s = append(s, "Field200: "+fmt.Sprintf("%#v", this.Field200)+",\n") + } + if this.Field210 != nil { + s = append(s, "Field210: "+valueToGoStringThetest(this.Field210, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinNestedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinNestedStructUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Tree) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.Tree{") + if this.Or != nil { + s = append(s, "Or: "+fmt.Sprintf("%#v", this.Or)+",\n") + } + if this.And != nil { + s = append(s, "And: "+fmt.Sprintf("%#v", this.And)+",\n") + } + if this.Leaf != nil { + s = append(s, "Leaf: "+fmt.Sprintf("%#v", this.Leaf)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OrBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.OrBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AndBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.AndBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Leaf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.Leaf{") + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + s = append(s, "StrValue: "+fmt.Sprintf("%#v", this.StrValue)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DeepTree) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.DeepTree{") + if this.Down != nil { + s = append(s, "Down: "+fmt.Sprintf("%#v", this.Down)+",\n") + } + if this.And != nil { + s = append(s, "And: "+fmt.Sprintf("%#v", this.And)+",\n") + } + if this.Leaf != nil { + s = append(s, "Leaf: "+fmt.Sprintf("%#v", this.Leaf)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *ADeepBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.ADeepBranch{") + s = append(s, "Down: "+strings.Replace(this.Down.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AndDeepBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.AndDeepBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DeepLeaf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.DeepLeaf{") + s = append(s, "Tree: "+strings.Replace(this.Tree.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Nil) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 4) + s = append(s, "&test.Nil{") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NidOptEnum{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinOptEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.TheTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NidRepEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinRepEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptEnumDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinOptEnumDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.TheTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AnotherNinOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.AnotherNinOptEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.AnotherTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AnotherNinOptEnumDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.AnotherNinOptEnumDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.AnotherTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Timer) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.Timer{") + s = append(s, "Time1: "+fmt.Sprintf("%#v", this.Time1)+",\n") + s = append(s, "Time2: "+fmt.Sprintf("%#v", this.Time2)+",\n") + s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MyExtendable) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.MyExtendable{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringThetest(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OtherExtenable) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.OtherExtenable{") + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "int64")+",\n") + } + if this.M != nil { + s = append(s, "M: "+fmt.Sprintf("%#v", this.M)+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringThetest(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&test.NestedDefinition{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.EnumField != nil { + s = append(s, "EnumField: "+valueToGoStringThetest(this.EnumField, "test.NestedDefinition_NestedEnum")+",\n") + } + if this.NNM != nil { + s = append(s, "NNM: "+fmt.Sprintf("%#v", this.NNM)+",\n") + } + if this.NM != nil { + s = append(s, "NM: "+fmt.Sprintf("%#v", this.NM)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition_NestedMessage) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NestedDefinition_NestedMessage{") + if this.NestedField1 != nil { + s = append(s, "NestedField1: "+valueToGoStringThetest(this.NestedField1, "uint64")+",\n") + } + if this.NNM != nil { + s = append(s, "NNM: "+fmt.Sprintf("%#v", this.NNM)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NestedDefinition_NestedMessage_NestedNestedMsg{") + if this.NestedNestedField1 != nil { + s = append(s, "NestedNestedField1: "+valueToGoStringThetest(this.NestedNestedField1, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedScope) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NestedScope{") + if this.A != nil { + s = append(s, "A: "+fmt.Sprintf("%#v", this.A)+",\n") + } + if this.B != nil { + s = append(s, "B: "+valueToGoStringThetest(this.B, "test.NestedDefinition_NestedEnum")+",\n") + } + if this.C != nil { + s = append(s, "C: "+fmt.Sprintf("%#v", this.C)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNativeDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinOptNativeDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+valueToGoStringThetest(this.Field8, "int64")+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+valueToGoStringThetest(this.Field9, "uint32")+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+valueToGoStringThetest(this.Field10, "int32")+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+valueToGoStringThetest(this.Field11, "uint64")+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+valueToGoStringThetest(this.Field12, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomContainer) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.CustomContainer{") + s = append(s, "CustomStruct: "+strings.Replace(this.CustomStruct.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNidOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNidOptNative{") + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + s = append(s, "FieldE: "+fmt.Sprintf("%#v", this.FieldE)+",\n") + s = append(s, "FieldF: "+fmt.Sprintf("%#v", this.FieldF)+",\n") + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + s = append(s, "FieldH: "+fmt.Sprintf("%#v", this.FieldH)+",\n") + s = append(s, "FieldI: "+fmt.Sprintf("%#v", this.FieldI)+",\n") + s = append(s, "FieldJ: "+fmt.Sprintf("%#v", this.FieldJ)+",\n") + s = append(s, "FieldK: "+fmt.Sprintf("%#v", this.FieldK)+",\n") + s = append(s, "FieldL: "+fmt.Sprintf("%#v", this.FieldL)+",\n") + s = append(s, "FieldM: "+fmt.Sprintf("%#v", this.FieldM)+",\n") + s = append(s, "FieldN: "+fmt.Sprintf("%#v", this.FieldN)+",\n") + s = append(s, "FieldO: "+fmt.Sprintf("%#v", this.FieldO)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNinOptNative{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "float64")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "float32")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+valueToGoStringThetest(this.FieldC, "int32")+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+valueToGoStringThetest(this.FieldD, "int64")+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+valueToGoStringThetest(this.FieldE, "uint32")+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+valueToGoStringThetest(this.FieldF, "uint64")+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+valueToGoStringThetest(this.FieldG, "int32")+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+valueToGoStringThetest(this.FieldH, "int64")+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+valueToGoStringThetest(this.FieldI, "uint32")+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+valueToGoStringThetest(this.FieldJ, "int32")+",\n") + } + if this.FieldK != nil { + s = append(s, "FieldK: "+valueToGoStringThetest(this.FieldK, "uint64")+",\n") + } + if this.FielL != nil { + s = append(s, "FielL: "+valueToGoStringThetest(this.FielL, "int64")+",\n") + } + if this.FieldM != nil { + s = append(s, "FieldM: "+valueToGoStringThetest(this.FieldM, "bool")+",\n") + } + if this.FieldN != nil { + s = append(s, "FieldN: "+valueToGoStringThetest(this.FieldN, "string")+",\n") + } + if this.FieldO != nil { + s = append(s, "FieldO: "+valueToGoStringThetest(this.FieldO, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNinRepNative{") + if this.FieldA != nil { + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+fmt.Sprintf("%#v", this.FieldE)+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+fmt.Sprintf("%#v", this.FieldF)+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+fmt.Sprintf("%#v", this.FieldH)+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+fmt.Sprintf("%#v", this.FieldI)+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+fmt.Sprintf("%#v", this.FieldJ)+",\n") + } + if this.FieldK != nil { + s = append(s, "FieldK: "+fmt.Sprintf("%#v", this.FieldK)+",\n") + } + if this.FieldL != nil { + s = append(s, "FieldL: "+fmt.Sprintf("%#v", this.FieldL)+",\n") + } + if this.FieldM != nil { + s = append(s, "FieldM: "+fmt.Sprintf("%#v", this.FieldM)+",\n") + } + if this.FieldN != nil { + s = append(s, "FieldN: "+fmt.Sprintf("%#v", this.FieldN)+",\n") + } + if this.FieldO != nil { + s = append(s, "FieldO: "+fmt.Sprintf("%#v", this.FieldO)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.CustomNameNinStruct{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "float64")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "float32")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+valueToGoStringThetest(this.FieldE, "uint64")+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+valueToGoStringThetest(this.FieldF, "int32")+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+valueToGoStringThetest(this.FieldH, "bool")+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+valueToGoStringThetest(this.FieldI, "string")+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+valueToGoStringThetest(this.FieldJ, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameCustomType) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&test.CustomNameCustomType{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "Uuid")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "github_com_gogo_protobuf_test_custom.Uint128")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinEmbeddedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.CustomNameNinEmbeddedStructUnion{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.FieldA != nil { + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.CustomNameEnum{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "test.TheTestEnum")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NoExtensionsMap) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NoExtensionsMap{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+fmt.Sprintf("%#v", this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Unrecognized) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.Unrecognized{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "string")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithInner) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.UnrecognizedWithInner{") + if this.Embedded != nil { + s = append(s, "Embedded: "+fmt.Sprintf("%#v", this.Embedded)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithInner_Inner) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.UnrecognizedWithInner_Inner{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "uint32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithEmbed) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.UnrecognizedWithEmbed{") + s = append(s, "UnrecognizedWithEmbed_Embedded: "+strings.Replace(this.UnrecognizedWithEmbed_Embedded.GoString(), `&`, ``, 1)+",\n") + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithEmbed_Embedded) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.UnrecognizedWithEmbed_Embedded{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "uint32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringThetest(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringThetest(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *NidOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(m.Field1))) + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(m.Field2))) + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3)) + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field4)) + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field5)) + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field6)) + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31)))) + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(m.Field8)<<1)^uint64((m.Field8>>63)))) + data[i] = 0x4d + i++ + i = encodeFixed32Thetest(data, i, uint32(m.Field9)) + data[i] = 0x55 + i++ + i = encodeFixed32Thetest(data, i, uint32(m.Field10)) + data[i] = 0x59 + i++ + i = encodeFixed64Thetest(data, i, uint64(m.Field11)) + data[i] = 0x61 + i++ + i = encodeFixed64Thetest(data, i, uint64(m.Field12)) + data[i] = 0x68 + i++ + if m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field14))) + i += copy(data[i:], m.Field14) + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(*m.Field1))) + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(*m.Field2))) + } + if m.Field3 != nil { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field3)) + } + if m.Field4 != nil { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field4)) + } + if m.Field5 != nil { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field5)) + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field8 != nil { + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(*m.Field8)<<1)^uint64((*m.Field8>>63)))) + } + if m.Field9 != nil { + data[i] = 0x4d + i++ + i = encodeFixed32Thetest(data, i, uint32(*m.Field9)) + } + if m.Field10 != nil { + data[i] = 0x55 + i++ + i = encodeFixed32Thetest(data, i, uint32(*m.Field10)) + } + if m.Field11 != nil { + data[i] = 0x59 + i++ + i = encodeFixed64Thetest(data, i, uint64(*m.Field11)) + } + if m.Field12 != nil { + data[i] = 0x61 + i++ + i = encodeFixed64Thetest(data, i, uint64(*m.Field12)) + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x9 + i++ + f1 := math.Float64bits(num) + data[i] = uint8(f1) + i++ + data[i] = uint8(f1 >> 8) + i++ + data[i] = uint8(f1 >> 16) + i++ + data[i] = uint8(f1 >> 24) + i++ + data[i] = uint8(f1 >> 32) + i++ + data[i] = uint8(f1 >> 40) + i++ + data[i] = uint8(f1 >> 48) + i++ + data[i] = uint8(f1 >> 56) + i++ + } + } + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x15 + i++ + f2 := math.Float32bits(num) + data[i] = uint8(f2) + i++ + data[i] = uint8(f2 >> 8) + i++ + data[i] = uint8(f2 >> 16) + i++ + data[i] = uint8(f2 >> 24) + i++ + } + } + if len(m.Field3) > 0 { + for _, num := range m.Field3 { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field4) > 0 { + for _, num := range m.Field4 { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field5) > 0 { + for _, num := range m.Field5 { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field6) > 0 { + for _, num := range m.Field6 { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x38 + i++ + x3 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x3 >= 1<<7 { + data[i] = uint8(uint64(x3)&0x7f | 0x80) + x3 >>= 7 + i++ + } + data[i] = uint8(x3) + i++ + } + } + if len(m.Field8) > 0 { + for _, num := range m.Field8 { + data[i] = 0x40 + i++ + x4 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x4 >= 1<<7 { + data[i] = uint8(uint64(x4)&0x7f | 0x80) + x4 >>= 7 + i++ + } + data[i] = uint8(x4) + i++ + } + } + if len(m.Field9) > 0 { + for _, num := range m.Field9 { + data[i] = 0x4d + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field10) > 0 { + for _, num := range m.Field10 { + data[i] = 0x55 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field11) > 0 { + for _, num := range m.Field11 { + data[i] = 0x59 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field12) > 0 { + for _, num := range m.Field12 { + data[i] = 0x61 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field13) > 0 { + for _, b := range m.Field13 { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x9 + i++ + f5 := math.Float64bits(num) + data[i] = uint8(f5) + i++ + data[i] = uint8(f5 >> 8) + i++ + data[i] = uint8(f5 >> 16) + i++ + data[i] = uint8(f5 >> 24) + i++ + data[i] = uint8(f5 >> 32) + i++ + data[i] = uint8(f5 >> 40) + i++ + data[i] = uint8(f5 >> 48) + i++ + data[i] = uint8(f5 >> 56) + i++ + } + } + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x15 + i++ + f6 := math.Float32bits(num) + data[i] = uint8(f6) + i++ + data[i] = uint8(f6 >> 8) + i++ + data[i] = uint8(f6 >> 16) + i++ + data[i] = uint8(f6 >> 24) + i++ + } + } + if len(m.Field3) > 0 { + for _, num := range m.Field3 { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field4) > 0 { + for _, num := range m.Field4 { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field5) > 0 { + for _, num := range m.Field5 { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field6) > 0 { + for _, num := range m.Field6 { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x38 + i++ + x7 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x7 >= 1<<7 { + data[i] = uint8(uint64(x7)&0x7f | 0x80) + x7 >>= 7 + i++ + } + data[i] = uint8(x7) + i++ + } + } + if len(m.Field8) > 0 { + for _, num := range m.Field8 { + data[i] = 0x40 + i++ + x8 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x8 >= 1<<7 { + data[i] = uint8(uint64(x8)&0x7f | 0x80) + x8 >>= 7 + i++ + } + data[i] = uint8(x8) + i++ + } + } + if len(m.Field9) > 0 { + for _, num := range m.Field9 { + data[i] = 0x4d + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field10) > 0 { + for _, num := range m.Field10 { + data[i] = 0x55 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field11) > 0 { + for _, num := range m.Field11 { + data[i] = 0x59 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field12) > 0 { + for _, num := range m.Field12 { + data[i] = 0x61 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field13) > 0 { + for _, b := range m.Field13 { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepPackedNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepPackedNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field1)*8)) + for _, num := range m.Field1 { + f9 := math.Float64bits(num) + data[i] = uint8(f9) + i++ + data[i] = uint8(f9 >> 8) + i++ + data[i] = uint8(f9 >> 16) + i++ + data[i] = uint8(f9 >> 24) + i++ + data[i] = uint8(f9 >> 32) + i++ + data[i] = uint8(f9 >> 40) + i++ + data[i] = uint8(f9 >> 48) + i++ + data[i] = uint8(f9 >> 56) + i++ + } + } + if len(m.Field2) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field2)*4)) + for _, num := range m.Field2 { + f10 := math.Float32bits(num) + data[i] = uint8(f10) + i++ + data[i] = uint8(f10 >> 8) + i++ + data[i] = uint8(f10 >> 16) + i++ + data[i] = uint8(f10 >> 24) + i++ + } + } + if len(m.Field3) > 0 { + data12 := make([]byte, len(m.Field3)*10) + var j11 int + for _, num1 := range m.Field3 { + num := uint64(num1) + for num >= 1<<7 { + data12[j11] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j11++ + } + data12[j11] = uint8(num) + j11++ + } + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(j11)) + i += copy(data[i:], data12[:j11]) + } + if len(m.Field4) > 0 { + data14 := make([]byte, len(m.Field4)*10) + var j13 int + for _, num1 := range m.Field4 { + num := uint64(num1) + for num >= 1<<7 { + data14[j13] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j13++ + } + data14[j13] = uint8(num) + j13++ + } + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(j13)) + i += copy(data[i:], data14[:j13]) + } + if len(m.Field5) > 0 { + data16 := make([]byte, len(m.Field5)*10) + var j15 int + for _, num := range m.Field5 { + for num >= 1<<7 { + data16[j15] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j15++ + } + data16[j15] = uint8(num) + j15++ + } + data[i] = 0x2a + i++ + i = encodeVarintThetest(data, i, uint64(j15)) + i += copy(data[i:], data16[:j15]) + } + if len(m.Field6) > 0 { + data18 := make([]byte, len(m.Field6)*10) + var j17 int + for _, num := range m.Field6 { + for num >= 1<<7 { + data18[j17] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j17++ + } + data18[j17] = uint8(num) + j17++ + } + data[i] = 0x32 + i++ + i = encodeVarintThetest(data, i, uint64(j17)) + i += copy(data[i:], data18[:j17]) + } + if len(m.Field7) > 0 { + data19 := make([]byte, len(m.Field7)*5) + var j20 int + for _, num := range m.Field7 { + x21 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x21 >= 1<<7 { + data19[j20] = uint8(uint64(x21)&0x7f | 0x80) + j20++ + x21 >>= 7 + } + data19[j20] = uint8(x21) + j20++ + } + data[i] = 0x3a + i++ + i = encodeVarintThetest(data, i, uint64(j20)) + i += copy(data[i:], data19[:j20]) + } + if len(m.Field8) > 0 { + var j22 int + data24 := make([]byte, len(m.Field8)*10) + for _, num := range m.Field8 { + x23 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x23 >= 1<<7 { + data24[j22] = uint8(uint64(x23)&0x7f | 0x80) + j22++ + x23 >>= 7 + } + data24[j22] = uint8(x23) + j22++ + } + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(j22)) + i += copy(data[i:], data24[:j22]) + } + if len(m.Field9) > 0 { + data[i] = 0x4a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field9)*4)) + for _, num := range m.Field9 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field10) > 0 { + data[i] = 0x52 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field10)*4)) + for _, num := range m.Field10 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field11) > 0 { + data[i] = 0x5a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field11)*8)) + for _, num := range m.Field11 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field12) > 0 { + data[i] = 0x62 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field12)*8)) + for _, num := range m.Field12 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field13) > 0 { + data[i] = 0x6a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field13))) + for _, b := range m.Field13 { + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepPackedNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepPackedNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field1)*8)) + for _, num := range m.Field1 { + f25 := math.Float64bits(num) + data[i] = uint8(f25) + i++ + data[i] = uint8(f25 >> 8) + i++ + data[i] = uint8(f25 >> 16) + i++ + data[i] = uint8(f25 >> 24) + i++ + data[i] = uint8(f25 >> 32) + i++ + data[i] = uint8(f25 >> 40) + i++ + data[i] = uint8(f25 >> 48) + i++ + data[i] = uint8(f25 >> 56) + i++ + } + } + if len(m.Field2) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field2)*4)) + for _, num := range m.Field2 { + f26 := math.Float32bits(num) + data[i] = uint8(f26) + i++ + data[i] = uint8(f26 >> 8) + i++ + data[i] = uint8(f26 >> 16) + i++ + data[i] = uint8(f26 >> 24) + i++ + } + } + if len(m.Field3) > 0 { + data28 := make([]byte, len(m.Field3)*10) + var j27 int + for _, num1 := range m.Field3 { + num := uint64(num1) + for num >= 1<<7 { + data28[j27] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j27++ + } + data28[j27] = uint8(num) + j27++ + } + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(j27)) + i += copy(data[i:], data28[:j27]) + } + if len(m.Field4) > 0 { + data30 := make([]byte, len(m.Field4)*10) + var j29 int + for _, num1 := range m.Field4 { + num := uint64(num1) + for num >= 1<<7 { + data30[j29] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j29++ + } + data30[j29] = uint8(num) + j29++ + } + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(j29)) + i += copy(data[i:], data30[:j29]) + } + if len(m.Field5) > 0 { + data32 := make([]byte, len(m.Field5)*10) + var j31 int + for _, num := range m.Field5 { + for num >= 1<<7 { + data32[j31] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j31++ + } + data32[j31] = uint8(num) + j31++ + } + data[i] = 0x2a + i++ + i = encodeVarintThetest(data, i, uint64(j31)) + i += copy(data[i:], data32[:j31]) + } + if len(m.Field6) > 0 { + data34 := make([]byte, len(m.Field6)*10) + var j33 int + for _, num := range m.Field6 { + for num >= 1<<7 { + data34[j33] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j33++ + } + data34[j33] = uint8(num) + j33++ + } + data[i] = 0x32 + i++ + i = encodeVarintThetest(data, i, uint64(j33)) + i += copy(data[i:], data34[:j33]) + } + if len(m.Field7) > 0 { + data35 := make([]byte, len(m.Field7)*5) + var j36 int + for _, num := range m.Field7 { + x37 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x37 >= 1<<7 { + data35[j36] = uint8(uint64(x37)&0x7f | 0x80) + j36++ + x37 >>= 7 + } + data35[j36] = uint8(x37) + j36++ + } + data[i] = 0x3a + i++ + i = encodeVarintThetest(data, i, uint64(j36)) + i += copy(data[i:], data35[:j36]) + } + if len(m.Field8) > 0 { + var j38 int + data40 := make([]byte, len(m.Field8)*10) + for _, num := range m.Field8 { + x39 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x39 >= 1<<7 { + data40[j38] = uint8(uint64(x39)&0x7f | 0x80) + j38++ + x39 >>= 7 + } + data40[j38] = uint8(x39) + j38++ + } + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(j38)) + i += copy(data[i:], data40[:j38]) + } + if len(m.Field9) > 0 { + data[i] = 0x4a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field9)*4)) + for _, num := range m.Field9 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field10) > 0 { + data[i] = 0x52 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field10)*4)) + for _, num := range m.Field10 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field11) > 0 { + data[i] = 0x5a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field11)*8)) + for _, num := range m.Field11 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field12) > 0 { + data[i] = 0x62 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field12)*8)) + for _, num := range m.Field12 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field13) > 0 { + data[i] = 0x6a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field13))) + for _, b := range m.Field13 { + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidOptStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidOptStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(m.Field1))) + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(m.Field2))) + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3.Size())) + n41, err := m.Field3.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n41 + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field4.Size())) + n42, err := m.Field4.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n42 + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field6)) + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31)))) + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field8.Size())) + n43, err := m.Field8.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n43 + data[i] = 0x68 + i++ + if m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field14))) + i += copy(data[i:], m.Field14) + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(*m.Field1))) + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(*m.Field2))) + } + if m.Field3 != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3.Size())) + n44, err := m.Field3.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n44 + } + if m.Field4 != nil { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field4.Size())) + n45, err := m.Field4.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n45 + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field8 != nil { + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field8.Size())) + n46, err := m.Field8.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n46 + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x9 + i++ + f47 := math.Float64bits(num) + data[i] = uint8(f47) + i++ + data[i] = uint8(f47 >> 8) + i++ + data[i] = uint8(f47 >> 16) + i++ + data[i] = uint8(f47 >> 24) + i++ + data[i] = uint8(f47 >> 32) + i++ + data[i] = uint8(f47 >> 40) + i++ + data[i] = uint8(f47 >> 48) + i++ + data[i] = uint8(f47 >> 56) + i++ + } + } + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x15 + i++ + f48 := math.Float32bits(num) + data[i] = uint8(f48) + i++ + data[i] = uint8(f48 >> 8) + i++ + data[i] = uint8(f48 >> 16) + i++ + data[i] = uint8(f48 >> 24) + i++ + } + } + if len(m.Field3) > 0 { + for _, msg := range m.Field3 { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field4) > 0 { + for _, msg := range m.Field4 { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field6) > 0 { + for _, num := range m.Field6 { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x38 + i++ + x49 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x49 >= 1<<7 { + data[i] = uint8(uint64(x49)&0x7f | 0x80) + x49 >>= 7 + i++ + } + data[i] = uint8(x49) + i++ + } + } + if len(m.Field8) > 0 { + for _, msg := range m.Field8 { + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field13) > 0 { + for _, b := range m.Field13 { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x9 + i++ + f50 := math.Float64bits(num) + data[i] = uint8(f50) + i++ + data[i] = uint8(f50 >> 8) + i++ + data[i] = uint8(f50 >> 16) + i++ + data[i] = uint8(f50 >> 24) + i++ + data[i] = uint8(f50 >> 32) + i++ + data[i] = uint8(f50 >> 40) + i++ + data[i] = uint8(f50 >> 48) + i++ + data[i] = uint8(f50 >> 56) + i++ + } + } + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x15 + i++ + f51 := math.Float32bits(num) + data[i] = uint8(f51) + i++ + data[i] = uint8(f51 >> 8) + i++ + data[i] = uint8(f51 >> 16) + i++ + data[i] = uint8(f51 >> 24) + i++ + } + } + if len(m.Field3) > 0 { + for _, msg := range m.Field3 { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field4) > 0 { + for _, msg := range m.Field4 { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field6) > 0 { + for _, num := range m.Field6 { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x38 + i++ + x52 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x52 >= 1<<7 { + data[i] = uint8(uint64(x52)&0x7f | 0x80) + x52 >>= 7 + i++ + } + data[i] = uint8(x52) + i++ + } + } + if len(m.Field8) > 0 { + for _, msg := range m.Field8 { + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field13) > 0 { + for _, b := range m.Field13 { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidEmbeddedStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidEmbeddedStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NidOptNative != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.NidOptNative.Size())) + n53, err := m.NidOptNative.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n53 + } + data[i] = 0xc2 + i++ + data[i] = 0xc + i++ + i = encodeVarintThetest(data, i, uint64(m.Field200.Size())) + n54, err := m.Field200.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n54 + data[i] = 0x90 + i++ + data[i] = 0xd + i++ + if m.Field210 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinEmbeddedStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinEmbeddedStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NidOptNative != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.NidOptNative.Size())) + n55, err := m.NidOptNative.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n55 + } + if m.Field200 != nil { + data[i] = 0xc2 + i++ + data[i] = 0xc + i++ + i = encodeVarintThetest(data, i, uint64(m.Field200.Size())) + n56, err := m.Field200.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n56 + } + if m.Field210 != nil { + data[i] = 0x90 + i++ + data[i] = 0xd + i++ + if *m.Field210 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidNestedStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidNestedStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Field1.Size())) + n57, err := m.Field1.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n57 + if len(m.Field2) > 0 { + for _, msg := range m.Field2 { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinNestedStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinNestedStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Field1.Size())) + n58, err := m.Field1.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n58 + } + if len(m.Field2) > 0 { + for _, msg := range m.Field2 { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidOptCustom) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidOptCustom) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Id.Size())) + n59, err := m.Id.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n59 + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Value.Size())) + n60, err := m.Value.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n60 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomDash) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomDash) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Value != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Value.Size())) + n61, err := m.Value.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n61 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptCustom) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptCustom) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Id != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Id.Size())) + n62, err := m.Id.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n62 + } + if m.Value != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Value.Size())) + n63, err := m.Value.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n63 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepCustom) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepCustom) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Id) > 0 { + for _, msg := range m.Id { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Value) > 0 { + for _, msg := range m.Value { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepCustom) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepCustom) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Id) > 0 { + for _, msg := range m.Id { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Value) > 0 { + for _, msg := range m.Value { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptNativeUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptNativeUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(*m.Field1))) + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(*m.Field2))) + } + if m.Field3 != nil { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field3)) + } + if m.Field4 != nil { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field4)) + } + if m.Field5 != nil { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field5)) + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptStructUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptStructUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(*m.Field1))) + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(*m.Field2))) + } + if m.Field3 != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3.Size())) + n64, err := m.Field3.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n64 + } + if m.Field4 != nil { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field4.Size())) + n65, err := m.Field4.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n65 + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinEmbeddedStructUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinEmbeddedStructUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NidOptNative != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.NidOptNative.Size())) + n66, err := m.NidOptNative.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n66 + } + if m.Field200 != nil { + data[i] = 0xc2 + i++ + data[i] = 0xc + i++ + i = encodeVarintThetest(data, i, uint64(m.Field200.Size())) + n67, err := m.Field200.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n67 + } + if m.Field210 != nil { + data[i] = 0x90 + i++ + data[i] = 0xd + i++ + if *m.Field210 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinNestedStructUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinNestedStructUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Field1.Size())) + n68, err := m.Field1.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n68 + } + if m.Field2 != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field2.Size())) + n69, err := m.Field2.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n69 + } + if m.Field3 != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3.Size())) + n70, err := m.Field3.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n70 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Tree) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Tree) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Or != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Or.Size())) + n71, err := m.Or.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n71 + } + if m.And != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.And.Size())) + n72, err := m.And.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n72 + } + if m.Leaf != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Leaf.Size())) + n73, err := m.Leaf.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n73 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *OrBranch) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *OrBranch) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Left.Size())) + n74, err := m.Left.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n74 + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Right.Size())) + n75, err := m.Right.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n75 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AndBranch) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AndBranch) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Left.Size())) + n76, err := m.Left.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n76 + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Right.Size())) + n77, err := m.Right.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n77 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Leaf) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Leaf) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(m.Value)) + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.StrValue))) + i += copy(data[i:], m.StrValue) + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *DeepTree) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *DeepTree) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Down != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Down.Size())) + n78, err := m.Down.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n78 + } + if m.And != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.And.Size())) + n79, err := m.And.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n79 + } + if m.Leaf != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Leaf.Size())) + n80, err := m.Leaf.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n80 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *ADeepBranch) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *ADeepBranch) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Down.Size())) + n81, err := m.Down.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n81 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AndDeepBranch) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AndDeepBranch) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Left.Size())) + n82, err := m.Left.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n82 + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Right.Size())) + n83, err := m.Right.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n83 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *DeepLeaf) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *DeepLeaf) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Tree.Size())) + n84, err := m.Tree.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n84 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Nil) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Nil) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidOptEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidOptEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field1)) + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptEnumDefault) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptEnumDefault) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AnotherNinOptEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AnotherNinOptEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AnotherNinOptEnumDefault) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AnotherNinOptEnumDefault) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Timer) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Timer) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(m.Time1)) + data[i] = 0x11 + i++ + i = encodeFixed64Thetest(data, i, uint64(m.Time2)) + if m.Data != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Data))) + i += copy(data[i:], m.Data) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *MyExtendable) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *MyExtendable) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if len(m.XXX_extensions) > 0 { + n, err := github_com_gogo_protobuf_proto.EncodeExtensionMap(m.XXX_extensions, data[i:]) + if err != nil { + return 0, err + } + i += n + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *OtherExtenable) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *OtherExtenable) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.M != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.M.Size())) + n85, err := m.M.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n85 + } + if m.Field2 != nil { + data[i] = 0x10 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field2)) + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field13)) + } + if len(m.XXX_extensions) > 0 { + n, err := github_com_gogo_protobuf_proto.EncodeExtensionMap(m.XXX_extensions, data[i:]) + if err != nil { + return 0, err + } + i += n + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NestedDefinition) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NestedDefinition) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.EnumField != nil { + data[i] = 0x10 + i++ + i = encodeVarintThetest(data, i, uint64(*m.EnumField)) + } + if m.NNM != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.NNM.Size())) + n86, err := m.NNM.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n86 + } + if m.NM != nil { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(m.NM.Size())) + n87, err := m.NM.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n87 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NestedDefinition_NestedMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NestedDefinition_NestedMessage) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NestedField1 != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(*m.NestedField1)) + } + if m.NNM != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.NNM.Size())) + n88, err := m.NNM.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n88 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NestedNestedField1 != nil { + data[i] = 0x52 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.NestedNestedField1))) + i += copy(data[i:], *m.NestedNestedField1) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NestedScope) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NestedScope) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.A != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.A.Size())) + n89, err := m.A.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n89 + } + if m.B != nil { + data[i] = 0x10 + i++ + i = encodeVarintThetest(data, i, uint64(*m.B)) + } + if m.C != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.C.Size())) + n90, err := m.C.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n90 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptNativeDefault) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptNativeDefault) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(*m.Field1))) + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(*m.Field2))) + } + if m.Field3 != nil { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field3)) + } + if m.Field4 != nil { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field4)) + } + if m.Field5 != nil { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field5)) + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field8 != nil { + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(*m.Field8)<<1)^uint64((*m.Field8>>63)))) + } + if m.Field9 != nil { + data[i] = 0x4d + i++ + i = encodeFixed32Thetest(data, i, uint32(*m.Field9)) + } + if m.Field10 != nil { + data[i] = 0x55 + i++ + i = encodeFixed32Thetest(data, i, uint32(*m.Field10)) + } + if m.Field11 != nil { + data[i] = 0x59 + i++ + i = encodeFixed64Thetest(data, i, uint64(*m.Field11)) + } + if m.Field12 != nil { + data[i] = 0x61 + i++ + i = encodeFixed64Thetest(data, i, uint64(*m.Field12)) + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomContainer) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomContainer) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.CustomStruct.Size())) + n91, err := m.CustomStruct.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n91 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNidOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNidOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(m.FieldA))) + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(m.FieldB))) + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldC)) + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldD)) + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldE)) + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldF)) + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(m.FieldG)<<1)^uint32((m.FieldG>>31)))) + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(m.FieldH)<<1)^uint64((m.FieldH>>63)))) + data[i] = 0x4d + i++ + i = encodeFixed32Thetest(data, i, uint32(m.FieldI)) + data[i] = 0x55 + i++ + i = encodeFixed32Thetest(data, i, uint32(m.FieldJ)) + data[i] = 0x59 + i++ + i = encodeFixed64Thetest(data, i, uint64(m.FieldK)) + data[i] = 0x61 + i++ + i = encodeFixed64Thetest(data, i, uint64(m.FieldL)) + data[i] = 0x68 + i++ + if m.FieldM { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.FieldN))) + i += copy(data[i:], m.FieldN) + if m.FieldO != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.FieldO))) + i += copy(data[i:], m.FieldO) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNinOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNinOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.FieldA != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(*m.FieldA))) + } + if m.FieldB != nil { + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(*m.FieldB))) + } + if m.FieldC != nil { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldC)) + } + if m.FieldD != nil { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldD)) + } + if m.FieldE != nil { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldE)) + } + if m.FieldF != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldF)) + } + if m.FieldG != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.FieldG)<<1)^uint32((*m.FieldG>>31)))) + } + if m.FieldH != nil { + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(*m.FieldH)<<1)^uint64((*m.FieldH>>63)))) + } + if m.FieldI != nil { + data[i] = 0x4d + i++ + i = encodeFixed32Thetest(data, i, uint32(*m.FieldI)) + } + if m.FieldJ != nil { + data[i] = 0x55 + i++ + i = encodeFixed32Thetest(data, i, uint32(*m.FieldJ)) + } + if m.FieldK != nil { + data[i] = 0x59 + i++ + i = encodeFixed64Thetest(data, i, uint64(*m.FieldK)) + } + if m.FielL != nil { + data[i] = 0x61 + i++ + i = encodeFixed64Thetest(data, i, uint64(*m.FielL)) + } + if m.FieldM != nil { + data[i] = 0x68 + i++ + if *m.FieldM { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.FieldN != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.FieldN))) + i += copy(data[i:], *m.FieldN) + } + if m.FieldO != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.FieldO))) + i += copy(data[i:], m.FieldO) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNinRepNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNinRepNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.FieldA) > 0 { + for _, num := range m.FieldA { + data[i] = 0x9 + i++ + f92 := math.Float64bits(num) + data[i] = uint8(f92) + i++ + data[i] = uint8(f92 >> 8) + i++ + data[i] = uint8(f92 >> 16) + i++ + data[i] = uint8(f92 >> 24) + i++ + data[i] = uint8(f92 >> 32) + i++ + data[i] = uint8(f92 >> 40) + i++ + data[i] = uint8(f92 >> 48) + i++ + data[i] = uint8(f92 >> 56) + i++ + } + } + if len(m.FieldB) > 0 { + for _, num := range m.FieldB { + data[i] = 0x15 + i++ + f93 := math.Float32bits(num) + data[i] = uint8(f93) + i++ + data[i] = uint8(f93 >> 8) + i++ + data[i] = uint8(f93 >> 16) + i++ + data[i] = uint8(f93 >> 24) + i++ + } + } + if len(m.FieldC) > 0 { + for _, num := range m.FieldC { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.FieldD) > 0 { + for _, num := range m.FieldD { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.FieldE) > 0 { + for _, num := range m.FieldE { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.FieldF) > 0 { + for _, num := range m.FieldF { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.FieldG) > 0 { + for _, num := range m.FieldG { + data[i] = 0x38 + i++ + x94 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x94 >= 1<<7 { + data[i] = uint8(uint64(x94)&0x7f | 0x80) + x94 >>= 7 + i++ + } + data[i] = uint8(x94) + i++ + } + } + if len(m.FieldH) > 0 { + for _, num := range m.FieldH { + data[i] = 0x40 + i++ + x95 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x95 >= 1<<7 { + data[i] = uint8(uint64(x95)&0x7f | 0x80) + x95 >>= 7 + i++ + } + data[i] = uint8(x95) + i++ + } + } + if len(m.FieldI) > 0 { + for _, num := range m.FieldI { + data[i] = 0x4d + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.FieldJ) > 0 { + for _, num := range m.FieldJ { + data[i] = 0x55 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.FieldK) > 0 { + for _, num := range m.FieldK { + data[i] = 0x59 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.FieldL) > 0 { + for _, num := range m.FieldL { + data[i] = 0x61 + i++ + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.FieldM) > 0 { + for _, b := range m.FieldM { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.FieldN) > 0 { + for _, s := range m.FieldN { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.FieldO) > 0 { + for _, b := range m.FieldO { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNinStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNinStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.FieldA != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Thetest(data, i, uint64(math.Float64bits(*m.FieldA))) + } + if m.FieldB != nil { + data[i] = 0x15 + i++ + i = encodeFixed32Thetest(data, i, uint32(math.Float32bits(*m.FieldB))) + } + if m.FieldC != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldC.Size())) + n96, err := m.FieldC.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n96 + } + if len(m.FieldD) > 0 { + for _, msg := range m.FieldD { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.FieldE != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldE)) + } + if m.FieldF != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.FieldF)<<1)^uint32((*m.FieldF>>31)))) + } + if m.FieldG != nil { + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldG.Size())) + n97, err := m.FieldG.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n97 + } + if m.FieldH != nil { + data[i] = 0x68 + i++ + if *m.FieldH { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.FieldI != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.FieldI))) + i += copy(data[i:], *m.FieldI) + } + if m.FieldJ != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.FieldJ))) + i += copy(data[i:], m.FieldJ) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameCustomType) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameCustomType) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.FieldA != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldA.Size())) + n98, err := m.FieldA.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n98 + } + if m.FieldB != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldB.Size())) + n99, err := m.FieldB.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n99 + } + if len(m.FieldC) > 0 { + for _, msg := range m.FieldC { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.FieldD) > 0 { + for _, msg := range m.FieldD { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNinEmbeddedStructUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNinEmbeddedStructUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NidOptNative != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.NidOptNative.Size())) + n100, err := m.NidOptNative.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n100 + } + if m.FieldA != nil { + data[i] = 0xc2 + i++ + data[i] = 0xc + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldA.Size())) + n101, err := m.FieldA.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n101 + } + if m.FieldB != nil { + data[i] = 0x90 + i++ + data[i] = 0xd + i++ + if *m.FieldB { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.FieldA != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldA)) + } + if len(m.FieldB) > 0 { + for _, num := range m.FieldB { + data[i] = 0x10 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NoExtensionsMap) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NoExtensionsMap) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + i += copy(data[i:], m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Unrecognized) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Unrecognized) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field1))) + i += copy(data[i:], *m.Field1) + } + return i, nil +} + +func (m *UnrecognizedWithInner) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnrecognizedWithInner) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Embedded) > 0 { + for _, msg := range m.Embedded { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.Field2 != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field2))) + i += copy(data[i:], *m.Field2) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *UnrecognizedWithInner_Inner) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnrecognizedWithInner_Inner) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + return i, nil +} + +func (m *UnrecognizedWithEmbed) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnrecognizedWithEmbed) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.UnrecognizedWithEmbed_Embedded.Size())) + n102, err := m.UnrecognizedWithEmbed_Embedded.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n102 + if m.Field2 != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field2))) + i += copy(data[i:], *m.Field2) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *UnrecognizedWithEmbed_Embedded) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnrecognizedWithEmbed_Embedded) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + return i, nil +} + +func encodeFixed64Thetest(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Thetest(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintThetest(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedNidOptNative(r randyThetest, easy bool) *NidOptNative { + this := &NidOptNative{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + this.Field5 = uint32(r.Uint32()) + this.Field6 = uint64(uint64(r.Uint32())) + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + this.Field9 = uint32(r.Uint32()) + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + this.Field11 = uint64(uint64(r.Uint32())) + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + this.Field13 = bool(bool(r.Intn(2) == 0)) + this.Field14 = randStringThetest(r) + v1 := r.Intn(100) + this.Field15 = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinOptNative(r randyThetest, easy bool) *NinOptNative { + this := &NinOptNative{} + if r.Intn(10) != 0 { + v2 := float64(r.Float64()) + if r.Intn(2) == 0 { + v2 *= -1 + } + this.Field1 = &v2 + } + if r.Intn(10) != 0 { + v3 := float32(r.Float32()) + if r.Intn(2) == 0 { + v3 *= -1 + } + this.Field2 = &v3 + } + if r.Intn(10) != 0 { + v4 := int32(r.Int31()) + if r.Intn(2) == 0 { + v4 *= -1 + } + this.Field3 = &v4 + } + if r.Intn(10) != 0 { + v5 := int64(r.Int63()) + if r.Intn(2) == 0 { + v5 *= -1 + } + this.Field4 = &v5 + } + if r.Intn(10) != 0 { + v6 := uint32(r.Uint32()) + this.Field5 = &v6 + } + if r.Intn(10) != 0 { + v7 := uint64(uint64(r.Uint32())) + this.Field6 = &v7 + } + if r.Intn(10) != 0 { + v8 := int32(r.Int31()) + if r.Intn(2) == 0 { + v8 *= -1 + } + this.Field7 = &v8 + } + if r.Intn(10) != 0 { + v9 := int64(r.Int63()) + if r.Intn(2) == 0 { + v9 *= -1 + } + this.Field8 = &v9 + } + if r.Intn(10) != 0 { + v10 := uint32(r.Uint32()) + this.Field9 = &v10 + } + if r.Intn(10) != 0 { + v11 := int32(r.Int31()) + if r.Intn(2) == 0 { + v11 *= -1 + } + this.Field10 = &v11 + } + if r.Intn(10) != 0 { + v12 := uint64(uint64(r.Uint32())) + this.Field11 = &v12 + } + if r.Intn(10) != 0 { + v13 := int64(r.Int63()) + if r.Intn(2) == 0 { + v13 *= -1 + } + this.Field12 = &v13 + } + if r.Intn(10) != 0 { + v14 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v14 + } + if r.Intn(10) != 0 { + v15 := randStringThetest(r) + this.Field14 = &v15 + } + if r.Intn(10) != 0 { + v16 := r.Intn(100) + this.Field15 = make([]byte, v16) + for i := 0; i < v16; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepNative(r randyThetest, easy bool) *NidRepNative { + this := &NidRepNative{} + if r.Intn(10) != 0 { + v17 := r.Intn(100) + this.Field1 = make([]float64, v17) + for i := 0; i < v17; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v18 := r.Intn(100) + this.Field2 = make([]float32, v18) + for i := 0; i < v18; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v19 := r.Intn(100) + this.Field3 = make([]int32, v19) + for i := 0; i < v19; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v20 := r.Intn(100) + this.Field4 = make([]int64, v20) + for i := 0; i < v20; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v21 := r.Intn(100) + this.Field5 = make([]uint32, v21) + for i := 0; i < v21; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v22 := r.Intn(100) + this.Field6 = make([]uint64, v22) + for i := 0; i < v22; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v23 := r.Intn(100) + this.Field7 = make([]int32, v23) + for i := 0; i < v23; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v24 := r.Intn(100) + this.Field8 = make([]int64, v24) + for i := 0; i < v24; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v25 := r.Intn(100) + this.Field9 = make([]uint32, v25) + for i := 0; i < v25; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v26 := r.Intn(100) + this.Field10 = make([]int32, v26) + for i := 0; i < v26; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v27 := r.Intn(100) + this.Field11 = make([]uint64, v27) + for i := 0; i < v27; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v28 := r.Intn(100) + this.Field12 = make([]int64, v28) + for i := 0; i < v28; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(100) + this.Field13 = make([]bool, v29) + for i := 0; i < v29; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v30 := r.Intn(10) + this.Field14 = make([]string, v30) + for i := 0; i < v30; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v31 := r.Intn(100) + this.Field15 = make([][]byte, v31) + for i := 0; i < v31; i++ { + v32 := r.Intn(100) + this.Field15[i] = make([]byte, v32) + for j := 0; j < v32; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinRepNative(r randyThetest, easy bool) *NinRepNative { + this := &NinRepNative{} + if r.Intn(10) != 0 { + v33 := r.Intn(100) + this.Field1 = make([]float64, v33) + for i := 0; i < v33; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v34 := r.Intn(100) + this.Field2 = make([]float32, v34) + for i := 0; i < v34; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v35 := r.Intn(100) + this.Field3 = make([]int32, v35) + for i := 0; i < v35; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v36 := r.Intn(100) + this.Field4 = make([]int64, v36) + for i := 0; i < v36; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v37 := r.Intn(100) + this.Field5 = make([]uint32, v37) + for i := 0; i < v37; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v38 := r.Intn(100) + this.Field6 = make([]uint64, v38) + for i := 0; i < v38; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v39 := r.Intn(100) + this.Field7 = make([]int32, v39) + for i := 0; i < v39; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v40 := r.Intn(100) + this.Field8 = make([]int64, v40) + for i := 0; i < v40; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v41 := r.Intn(100) + this.Field9 = make([]uint32, v41) + for i := 0; i < v41; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v42 := r.Intn(100) + this.Field10 = make([]int32, v42) + for i := 0; i < v42; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v43 := r.Intn(100) + this.Field11 = make([]uint64, v43) + for i := 0; i < v43; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v44 := r.Intn(100) + this.Field12 = make([]int64, v44) + for i := 0; i < v44; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v45 := r.Intn(100) + this.Field13 = make([]bool, v45) + for i := 0; i < v45; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v46 := r.Intn(10) + this.Field14 = make([]string, v46) + for i := 0; i < v46; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v47 := r.Intn(100) + this.Field15 = make([][]byte, v47) + for i := 0; i < v47; i++ { + v48 := r.Intn(100) + this.Field15[i] = make([]byte, v48) + for j := 0; j < v48; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepPackedNative(r randyThetest, easy bool) *NidRepPackedNative { + this := &NidRepPackedNative{} + if r.Intn(10) != 0 { + v49 := r.Intn(100) + this.Field1 = make([]float64, v49) + for i := 0; i < v49; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v50 := r.Intn(100) + this.Field2 = make([]float32, v50) + for i := 0; i < v50; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v51 := r.Intn(100) + this.Field3 = make([]int32, v51) + for i := 0; i < v51; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v52 := r.Intn(100) + this.Field4 = make([]int64, v52) + for i := 0; i < v52; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v53 := r.Intn(100) + this.Field5 = make([]uint32, v53) + for i := 0; i < v53; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v54 := r.Intn(100) + this.Field6 = make([]uint64, v54) + for i := 0; i < v54; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v55 := r.Intn(100) + this.Field7 = make([]int32, v55) + for i := 0; i < v55; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v56 := r.Intn(100) + this.Field8 = make([]int64, v56) + for i := 0; i < v56; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v57 := r.Intn(100) + this.Field9 = make([]uint32, v57) + for i := 0; i < v57; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v58 := r.Intn(100) + this.Field10 = make([]int32, v58) + for i := 0; i < v58; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v59 := r.Intn(100) + this.Field11 = make([]uint64, v59) + for i := 0; i < v59; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v60 := r.Intn(100) + this.Field12 = make([]int64, v60) + for i := 0; i < v60; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v61 := r.Intn(100) + this.Field13 = make([]bool, v61) + for i := 0; i < v61; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 14) + } + return this +} + +func NewPopulatedNinRepPackedNative(r randyThetest, easy bool) *NinRepPackedNative { + this := &NinRepPackedNative{} + if r.Intn(10) != 0 { + v62 := r.Intn(100) + this.Field1 = make([]float64, v62) + for i := 0; i < v62; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v63 := r.Intn(100) + this.Field2 = make([]float32, v63) + for i := 0; i < v63; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v64 := r.Intn(100) + this.Field3 = make([]int32, v64) + for i := 0; i < v64; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v65 := r.Intn(100) + this.Field4 = make([]int64, v65) + for i := 0; i < v65; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v66 := r.Intn(100) + this.Field5 = make([]uint32, v66) + for i := 0; i < v66; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v67 := r.Intn(100) + this.Field6 = make([]uint64, v67) + for i := 0; i < v67; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v68 := r.Intn(100) + this.Field7 = make([]int32, v68) + for i := 0; i < v68; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v69 := r.Intn(100) + this.Field8 = make([]int64, v69) + for i := 0; i < v69; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v70 := r.Intn(100) + this.Field9 = make([]uint32, v70) + for i := 0; i < v70; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v71 := r.Intn(100) + this.Field10 = make([]int32, v71) + for i := 0; i < v71; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v72 := r.Intn(100) + this.Field11 = make([]uint64, v72) + for i := 0; i < v72; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v73 := r.Intn(100) + this.Field12 = make([]int64, v73) + for i := 0; i < v73; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v74 := r.Intn(100) + this.Field13 = make([]bool, v74) + for i := 0; i < v74; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 14) + } + return this +} + +func NewPopulatedNidOptStruct(r randyThetest, easy bool) *NidOptStruct { + this := &NidOptStruct{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + v75 := NewPopulatedNidOptNative(r, easy) + this.Field3 = *v75 + v76 := NewPopulatedNinOptNative(r, easy) + this.Field4 = *v76 + this.Field6 = uint64(uint64(r.Uint32())) + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + v77 := NewPopulatedNidOptNative(r, easy) + this.Field8 = *v77 + this.Field13 = bool(bool(r.Intn(2) == 0)) + this.Field14 = randStringThetest(r) + v78 := r.Intn(100) + this.Field15 = make([]byte, v78) + for i := 0; i < v78; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinOptStruct(r randyThetest, easy bool) *NinOptStruct { + this := &NinOptStruct{} + if r.Intn(10) != 0 { + v79 := float64(r.Float64()) + if r.Intn(2) == 0 { + v79 *= -1 + } + this.Field1 = &v79 + } + if r.Intn(10) != 0 { + v80 := float32(r.Float32()) + if r.Intn(2) == 0 { + v80 *= -1 + } + this.Field2 = &v80 + } + if r.Intn(10) != 0 { + this.Field3 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + this.Field4 = NewPopulatedNinOptNative(r, easy) + } + if r.Intn(10) != 0 { + v81 := uint64(uint64(r.Uint32())) + this.Field6 = &v81 + } + if r.Intn(10) != 0 { + v82 := int32(r.Int31()) + if r.Intn(2) == 0 { + v82 *= -1 + } + this.Field7 = &v82 + } + if r.Intn(10) != 0 { + this.Field8 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v83 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v83 + } + if r.Intn(10) != 0 { + v84 := randStringThetest(r) + this.Field14 = &v84 + } + if r.Intn(10) != 0 { + v85 := r.Intn(100) + this.Field15 = make([]byte, v85) + for i := 0; i < v85; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepStruct(r randyThetest, easy bool) *NidRepStruct { + this := &NidRepStruct{} + if r.Intn(10) != 0 { + v86 := r.Intn(100) + this.Field1 = make([]float64, v86) + for i := 0; i < v86; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v87 := r.Intn(100) + this.Field2 = make([]float32, v87) + for i := 0; i < v87; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v88 := r.Intn(10) + this.Field3 = make([]NidOptNative, v88) + for i := 0; i < v88; i++ { + v89 := NewPopulatedNidOptNative(r, easy) + this.Field3[i] = *v89 + } + } + if r.Intn(10) != 0 { + v90 := r.Intn(10) + this.Field4 = make([]NinOptNative, v90) + for i := 0; i < v90; i++ { + v91 := NewPopulatedNinOptNative(r, easy) + this.Field4[i] = *v91 + } + } + if r.Intn(10) != 0 { + v92 := r.Intn(100) + this.Field6 = make([]uint64, v92) + for i := 0; i < v92; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v93 := r.Intn(100) + this.Field7 = make([]int32, v93) + for i := 0; i < v93; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v94 := r.Intn(10) + this.Field8 = make([]NidOptNative, v94) + for i := 0; i < v94; i++ { + v95 := NewPopulatedNidOptNative(r, easy) + this.Field8[i] = *v95 + } + } + if r.Intn(10) != 0 { + v96 := r.Intn(100) + this.Field13 = make([]bool, v96) + for i := 0; i < v96; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v97 := r.Intn(10) + this.Field14 = make([]string, v97) + for i := 0; i < v97; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v98 := r.Intn(100) + this.Field15 = make([][]byte, v98) + for i := 0; i < v98; i++ { + v99 := r.Intn(100) + this.Field15[i] = make([]byte, v99) + for j := 0; j < v99; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinRepStruct(r randyThetest, easy bool) *NinRepStruct { + this := &NinRepStruct{} + if r.Intn(10) != 0 { + v100 := r.Intn(100) + this.Field1 = make([]float64, v100) + for i := 0; i < v100; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v101 := r.Intn(100) + this.Field2 = make([]float32, v101) + for i := 0; i < v101; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v102 := r.Intn(10) + this.Field3 = make([]*NidOptNative, v102) + for i := 0; i < v102; i++ { + this.Field3[i] = NewPopulatedNidOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v103 := r.Intn(10) + this.Field4 = make([]*NinOptNative, v103) + for i := 0; i < v103; i++ { + this.Field4[i] = NewPopulatedNinOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v104 := r.Intn(100) + this.Field6 = make([]uint64, v104) + for i := 0; i < v104; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v105 := r.Intn(100) + this.Field7 = make([]int32, v105) + for i := 0; i < v105; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v106 := r.Intn(10) + this.Field8 = make([]*NidOptNative, v106) + for i := 0; i < v106; i++ { + this.Field8[i] = NewPopulatedNidOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v107 := r.Intn(100) + this.Field13 = make([]bool, v107) + for i := 0; i < v107; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v108 := r.Intn(10) + this.Field14 = make([]string, v108) + for i := 0; i < v108; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v109 := r.Intn(100) + this.Field15 = make([][]byte, v109) + for i := 0; i < v109; i++ { + v110 := r.Intn(100) + this.Field15[i] = make([]byte, v110) + for j := 0; j < v110; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidEmbeddedStruct(r randyThetest, easy bool) *NidEmbeddedStruct { + this := &NidEmbeddedStruct{} + if r.Intn(10) != 0 { + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + } + v111 := NewPopulatedNidOptNative(r, easy) + this.Field200 = *v111 + this.Field210 = bool(bool(r.Intn(2) == 0)) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 211) + } + return this +} + +func NewPopulatedNinEmbeddedStruct(r randyThetest, easy bool) *NinEmbeddedStruct { + this := &NinEmbeddedStruct{} + if r.Intn(10) != 0 { + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + this.Field200 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v112 := bool(bool(r.Intn(2) == 0)) + this.Field210 = &v112 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 211) + } + return this +} + +func NewPopulatedNidNestedStruct(r randyThetest, easy bool) *NidNestedStruct { + this := &NidNestedStruct{} + v113 := NewPopulatedNidOptStruct(r, easy) + this.Field1 = *v113 + if r.Intn(10) != 0 { + v114 := r.Intn(10) + this.Field2 = make([]NidRepStruct, v114) + for i := 0; i < v114; i++ { + v115 := NewPopulatedNidRepStruct(r, easy) + this.Field2[i] = *v115 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinNestedStruct(r randyThetest, easy bool) *NinNestedStruct { + this := &NinNestedStruct{} + if r.Intn(10) != 0 { + this.Field1 = NewPopulatedNinOptStruct(r, easy) + } + if r.Intn(10) != 0 { + v116 := r.Intn(10) + this.Field2 = make([]*NinRepStruct, v116) + for i := 0; i < v116; i++ { + this.Field2[i] = NewPopulatedNinRepStruct(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNidOptCustom(r randyThetest, easy bool) *NidOptCustom { + this := &NidOptCustom{} + v117 := NewPopulatedUuid(r) + this.Id = *v117 + v118 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value = *v118 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedCustomDash(r randyThetest, easy bool) *CustomDash { + this := &CustomDash{} + if r.Intn(10) != 0 { + this.Value = github_com_gogo_protobuf_test_custom_dash_type.NewPopulatedBytes(r) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptCustom(r randyThetest, easy bool) *NinOptCustom { + this := &NinOptCustom{} + if r.Intn(10) != 0 { + this.Id = NewPopulatedUuid(r) + } + if r.Intn(10) != 0 { + this.Value = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNidRepCustom(r randyThetest, easy bool) *NidRepCustom { + this := &NidRepCustom{} + if r.Intn(10) != 0 { + v119 := r.Intn(10) + this.Id = make([]Uuid, v119) + for i := 0; i < v119; i++ { + v120 := NewPopulatedUuid(r) + this.Id[i] = *v120 + } + } + if r.Intn(10) != 0 { + v121 := r.Intn(10) + this.Value = make([]github_com_gogo_protobuf_test_custom.Uint128, v121) + for i := 0; i < v121; i++ { + v122 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value[i] = *v122 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinRepCustom(r randyThetest, easy bool) *NinRepCustom { + this := &NinRepCustom{} + if r.Intn(10) != 0 { + v123 := r.Intn(10) + this.Id = make([]Uuid, v123) + for i := 0; i < v123; i++ { + v124 := NewPopulatedUuid(r) + this.Id[i] = *v124 + } + } + if r.Intn(10) != 0 { + v125 := r.Intn(10) + this.Value = make([]github_com_gogo_protobuf_test_custom.Uint128, v125) + for i := 0; i < v125; i++ { + v126 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value[i] = *v126 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinOptNativeUnion(r randyThetest, easy bool) *NinOptNativeUnion { + this := &NinOptNativeUnion{} + fieldNum := r.Intn(9) + switch fieldNum { + case 0: + v127 := float64(r.Float64()) + if r.Intn(2) == 0 { + v127 *= -1 + } + this.Field1 = &v127 + case 1: + v128 := float32(r.Float32()) + if r.Intn(2) == 0 { + v128 *= -1 + } + this.Field2 = &v128 + case 2: + v129 := int32(r.Int31()) + if r.Intn(2) == 0 { + v129 *= -1 + } + this.Field3 = &v129 + case 3: + v130 := int64(r.Int63()) + if r.Intn(2) == 0 { + v130 *= -1 + } + this.Field4 = &v130 + case 4: + v131 := uint32(r.Uint32()) + this.Field5 = &v131 + case 5: + v132 := uint64(uint64(r.Uint32())) + this.Field6 = &v132 + case 6: + v133 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v133 + case 7: + v134 := randStringThetest(r) + this.Field14 = &v134 + case 8: + v135 := r.Intn(100) + this.Field15 = make([]byte, v135) + for i := 0; i < v135; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + return this +} + +func NewPopulatedNinOptStructUnion(r randyThetest, easy bool) *NinOptStructUnion { + this := &NinOptStructUnion{} + fieldNum := r.Intn(9) + switch fieldNum { + case 0: + v136 := float64(r.Float64()) + if r.Intn(2) == 0 { + v136 *= -1 + } + this.Field1 = &v136 + case 1: + v137 := float32(r.Float32()) + if r.Intn(2) == 0 { + v137 *= -1 + } + this.Field2 = &v137 + case 2: + this.Field3 = NewPopulatedNidOptNative(r, easy) + case 3: + this.Field4 = NewPopulatedNinOptNative(r, easy) + case 4: + v138 := uint64(uint64(r.Uint32())) + this.Field6 = &v138 + case 5: + v139 := int32(r.Int31()) + if r.Intn(2) == 0 { + v139 *= -1 + } + this.Field7 = &v139 + case 6: + v140 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v140 + case 7: + v141 := randStringThetest(r) + this.Field14 = &v141 + case 8: + v142 := r.Intn(100) + this.Field15 = make([]byte, v142) + for i := 0; i < v142; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + return this +} + +func NewPopulatedNinEmbeddedStructUnion(r randyThetest, easy bool) *NinEmbeddedStructUnion { + this := &NinEmbeddedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + case 1: + this.Field200 = NewPopulatedNinOptNative(r, easy) + case 2: + v143 := bool(bool(r.Intn(2) == 0)) + this.Field210 = &v143 + } + return this +} + +func NewPopulatedNinNestedStructUnion(r randyThetest, easy bool) *NinNestedStructUnion { + this := &NinNestedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.Field1 = NewPopulatedNinOptNativeUnion(r, easy) + case 1: + this.Field2 = NewPopulatedNinOptStructUnion(r, easy) + case 2: + this.Field3 = NewPopulatedNinEmbeddedStructUnion(r, easy) + } + return this +} + +func NewPopulatedTree(r randyThetest, easy bool) *Tree { + this := &Tree{} + fieldNum := r.Intn(102) + switch fieldNum { + case 0: + this.Or = NewPopulatedOrBranch(r, easy) + case 1: + this.And = NewPopulatedAndBranch(r, easy) + case 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101: + this.Leaf = NewPopulatedLeaf(r, easy) + } + return this +} + +func NewPopulatedOrBranch(r randyThetest, easy bool) *OrBranch { + this := &OrBranch{} + v144 := NewPopulatedTree(r, easy) + this.Left = *v144 + v145 := NewPopulatedTree(r, easy) + this.Right = *v145 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedAndBranch(r randyThetest, easy bool) *AndBranch { + this := &AndBranch{} + v146 := NewPopulatedTree(r, easy) + this.Left = *v146 + v147 := NewPopulatedTree(r, easy) + this.Right = *v147 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedLeaf(r randyThetest, easy bool) *Leaf { + this := &Leaf{} + this.Value = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Value *= -1 + } + this.StrValue = randStringThetest(r) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedDeepTree(r randyThetest, easy bool) *DeepTree { + this := &DeepTree{} + fieldNum := r.Intn(102) + switch fieldNum { + case 0: + this.Down = NewPopulatedADeepBranch(r, easy) + case 1: + this.And = NewPopulatedAndDeepBranch(r, easy) + case 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101: + this.Leaf = NewPopulatedDeepLeaf(r, easy) + } + return this +} + +func NewPopulatedADeepBranch(r randyThetest, easy bool) *ADeepBranch { + this := &ADeepBranch{} + v148 := NewPopulatedDeepTree(r, easy) + this.Down = *v148 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedAndDeepBranch(r randyThetest, easy bool) *AndDeepBranch { + this := &AndDeepBranch{} + v149 := NewPopulatedDeepTree(r, easy) + this.Left = *v149 + v150 := NewPopulatedDeepTree(r, easy) + this.Right = *v150 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedDeepLeaf(r randyThetest, easy bool) *DeepLeaf { + this := &DeepLeaf{} + v151 := NewPopulatedTree(r, easy) + this.Tree = *v151 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNil(r randyThetest, easy bool) *Nil { + this := &Nil{} + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 1) + } + return this +} + +func NewPopulatedNidOptEnum(r randyThetest, easy bool) *NidOptEnum { + this := &NidOptEnum{} + this.Field1 = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptEnum(r randyThetest, easy bool) *NinOptEnum { + this := &NinOptEnum{} + if r.Intn(10) != 0 { + v152 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.Field1 = &v152 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNidRepEnum(r randyThetest, easy bool) *NidRepEnum { + this := &NidRepEnum{} + if r.Intn(10) != 0 { + v153 := r.Intn(10) + this.Field1 = make([]TheTestEnum, v153) + for i := 0; i < v153; i++ { + this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinRepEnum(r randyThetest, easy bool) *NinRepEnum { + this := &NinRepEnum{} + if r.Intn(10) != 0 { + v154 := r.Intn(10) + this.Field1 = make([]TheTestEnum, v154) + for i := 0; i < v154; i++ { + this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptEnumDefault(r randyThetest, easy bool) *NinOptEnumDefault { + this := &NinOptEnumDefault{} + if r.Intn(10) != 0 { + v155 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.Field1 = &v155 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedAnotherNinOptEnum(r randyThetest, easy bool) *AnotherNinOptEnum { + this := &AnotherNinOptEnum{} + if r.Intn(10) != 0 { + v156 := AnotherTestEnum([]int32{10, 11}[r.Intn(2)]) + this.Field1 = &v156 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedAnotherNinOptEnumDefault(r randyThetest, easy bool) *AnotherNinOptEnumDefault { + this := &AnotherNinOptEnumDefault{} + if r.Intn(10) != 0 { + v157 := AnotherTestEnum([]int32{10, 11}[r.Intn(2)]) + this.Field1 = &v157 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedTimer(r randyThetest, easy bool) *Timer { + this := &Timer{} + this.Time1 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Time1 *= -1 + } + this.Time2 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Time2 *= -1 + } + v158 := r.Intn(100) + this.Data = make([]byte, v158) + for i := 0; i < v158; i++ { + this.Data[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 4) + } + return this +} + +func NewPopulatedMyExtendable(r randyThetest, easy bool) *MyExtendable { + this := &MyExtendable{} + if r.Intn(10) != 0 { + v159 := int64(r.Int63()) + if r.Intn(2) == 0 { + v159 *= -1 + } + this.Field1 = &v159 + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + fieldNumber := r.Intn(100) + 100 + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 201) + } + return this +} + +func NewPopulatedOtherExtenable(r randyThetest, easy bool) *OtherExtenable { + this := &OtherExtenable{} + if r.Intn(10) != 0 { + this.M = NewPopulatedMyExtendable(r, easy) + } + if r.Intn(10) != 0 { + v160 := int64(r.Int63()) + if r.Intn(2) == 0 { + v160 *= -1 + } + this.Field2 = &v160 + } + if r.Intn(10) != 0 { + v161 := int64(r.Int63()) + if r.Intn(2) == 0 { + v161 *= -1 + } + this.Field13 = &v161 + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + eIndex := r.Intn(2) + fieldNumber := 0 + switch eIndex { + case 0: + fieldNumber = r.Intn(3) + 14 + case 1: + fieldNumber = r.Intn(3) + 10 + } + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 18) + } + return this +} + +func NewPopulatedNestedDefinition(r randyThetest, easy bool) *NestedDefinition { + this := &NestedDefinition{} + if r.Intn(10) != 0 { + v162 := int64(r.Int63()) + if r.Intn(2) == 0 { + v162 *= -1 + } + this.Field1 = &v162 + } + if r.Intn(10) != 0 { + v163 := NestedDefinition_NestedEnum([]int32{1}[r.Intn(1)]) + this.EnumField = &v163 + } + if r.Intn(10) != 0 { + this.NNM = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if r.Intn(10) != 0 { + this.NM = NewPopulatedNestedDefinition_NestedMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 5) + } + return this +} + +func NewPopulatedNestedDefinition_NestedMessage(r randyThetest, easy bool) *NestedDefinition_NestedMessage { + this := &NestedDefinition_NestedMessage{} + if r.Intn(10) != 0 { + v164 := uint64(uint64(r.Uint32())) + this.NestedField1 = &v164 + } + if r.Intn(10) != 0 { + this.NNM = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r randyThetest, easy bool) *NestedDefinition_NestedMessage_NestedNestedMsg { + this := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if r.Intn(10) != 0 { + v165 := randStringThetest(r) + this.NestedNestedField1 = &v165 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 11) + } + return this +} + +func NewPopulatedNestedScope(r randyThetest, easy bool) *NestedScope { + this := &NestedScope{} + if r.Intn(10) != 0 { + this.A = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if r.Intn(10) != 0 { + v166 := NestedDefinition_NestedEnum([]int32{1}[r.Intn(1)]) + this.B = &v166 + } + if r.Intn(10) != 0 { + this.C = NewPopulatedNestedDefinition_NestedMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 4) + } + return this +} + +func NewPopulatedNinOptNativeDefault(r randyThetest, easy bool) *NinOptNativeDefault { + this := &NinOptNativeDefault{} + if r.Intn(10) != 0 { + v167 := float64(r.Float64()) + if r.Intn(2) == 0 { + v167 *= -1 + } + this.Field1 = &v167 + } + if r.Intn(10) != 0 { + v168 := float32(r.Float32()) + if r.Intn(2) == 0 { + v168 *= -1 + } + this.Field2 = &v168 + } + if r.Intn(10) != 0 { + v169 := int32(r.Int31()) + if r.Intn(2) == 0 { + v169 *= -1 + } + this.Field3 = &v169 + } + if r.Intn(10) != 0 { + v170 := int64(r.Int63()) + if r.Intn(2) == 0 { + v170 *= -1 + } + this.Field4 = &v170 + } + if r.Intn(10) != 0 { + v171 := uint32(r.Uint32()) + this.Field5 = &v171 + } + if r.Intn(10) != 0 { + v172 := uint64(uint64(r.Uint32())) + this.Field6 = &v172 + } + if r.Intn(10) != 0 { + v173 := int32(r.Int31()) + if r.Intn(2) == 0 { + v173 *= -1 + } + this.Field7 = &v173 + } + if r.Intn(10) != 0 { + v174 := int64(r.Int63()) + if r.Intn(2) == 0 { + v174 *= -1 + } + this.Field8 = &v174 + } + if r.Intn(10) != 0 { + v175 := uint32(r.Uint32()) + this.Field9 = &v175 + } + if r.Intn(10) != 0 { + v176 := int32(r.Int31()) + if r.Intn(2) == 0 { + v176 *= -1 + } + this.Field10 = &v176 + } + if r.Intn(10) != 0 { + v177 := uint64(uint64(r.Uint32())) + this.Field11 = &v177 + } + if r.Intn(10) != 0 { + v178 := int64(r.Int63()) + if r.Intn(2) == 0 { + v178 *= -1 + } + this.Field12 = &v178 + } + if r.Intn(10) != 0 { + v179 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v179 + } + if r.Intn(10) != 0 { + v180 := randStringThetest(r) + this.Field14 = &v180 + } + if r.Intn(10) != 0 { + v181 := r.Intn(100) + this.Field15 = make([]byte, v181) + for i := 0; i < v181; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomContainer(r randyThetest, easy bool) *CustomContainer { + this := &CustomContainer{} + v182 := NewPopulatedNidOptCustom(r, easy) + this.CustomStruct = *v182 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedCustomNameNidOptNative(r randyThetest, easy bool) *CustomNameNidOptNative { + this := &CustomNameNidOptNative{} + this.FieldA = float64(r.Float64()) + if r.Intn(2) == 0 { + this.FieldA *= -1 + } + this.FieldB = float32(r.Float32()) + if r.Intn(2) == 0 { + this.FieldB *= -1 + } + this.FieldC = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldC *= -1 + } + this.FieldD = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldD *= -1 + } + this.FieldE = uint32(r.Uint32()) + this.FieldF = uint64(uint64(r.Uint32())) + this.FieldG = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldG *= -1 + } + this.FieldH = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldH *= -1 + } + this.FieldI = uint32(r.Uint32()) + this.FieldJ = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldJ *= -1 + } + this.FieldK = uint64(uint64(r.Uint32())) + this.FieldL = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldL *= -1 + } + this.FieldM = bool(bool(r.Intn(2) == 0)) + this.FieldN = randStringThetest(r) + v183 := r.Intn(100) + this.FieldO = make([]byte, v183) + for i := 0; i < v183; i++ { + this.FieldO[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinOptNative(r randyThetest, easy bool) *CustomNameNinOptNative { + this := &CustomNameNinOptNative{} + if r.Intn(10) != 0 { + v184 := float64(r.Float64()) + if r.Intn(2) == 0 { + v184 *= -1 + } + this.FieldA = &v184 + } + if r.Intn(10) != 0 { + v185 := float32(r.Float32()) + if r.Intn(2) == 0 { + v185 *= -1 + } + this.FieldB = &v185 + } + if r.Intn(10) != 0 { + v186 := int32(r.Int31()) + if r.Intn(2) == 0 { + v186 *= -1 + } + this.FieldC = &v186 + } + if r.Intn(10) != 0 { + v187 := int64(r.Int63()) + if r.Intn(2) == 0 { + v187 *= -1 + } + this.FieldD = &v187 + } + if r.Intn(10) != 0 { + v188 := uint32(r.Uint32()) + this.FieldE = &v188 + } + if r.Intn(10) != 0 { + v189 := uint64(uint64(r.Uint32())) + this.FieldF = &v189 + } + if r.Intn(10) != 0 { + v190 := int32(r.Int31()) + if r.Intn(2) == 0 { + v190 *= -1 + } + this.FieldG = &v190 + } + if r.Intn(10) != 0 { + v191 := int64(r.Int63()) + if r.Intn(2) == 0 { + v191 *= -1 + } + this.FieldH = &v191 + } + if r.Intn(10) != 0 { + v192 := uint32(r.Uint32()) + this.FieldI = &v192 + } + if r.Intn(10) != 0 { + v193 := int32(r.Int31()) + if r.Intn(2) == 0 { + v193 *= -1 + } + this.FieldJ = &v193 + } + if r.Intn(10) != 0 { + v194 := uint64(uint64(r.Uint32())) + this.FieldK = &v194 + } + if r.Intn(10) != 0 { + v195 := int64(r.Int63()) + if r.Intn(2) == 0 { + v195 *= -1 + } + this.FielL = &v195 + } + if r.Intn(10) != 0 { + v196 := bool(bool(r.Intn(2) == 0)) + this.FieldM = &v196 + } + if r.Intn(10) != 0 { + v197 := randStringThetest(r) + this.FieldN = &v197 + } + if r.Intn(10) != 0 { + v198 := r.Intn(100) + this.FieldO = make([]byte, v198) + for i := 0; i < v198; i++ { + this.FieldO[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinRepNative(r randyThetest, easy bool) *CustomNameNinRepNative { + this := &CustomNameNinRepNative{} + if r.Intn(10) != 0 { + v199 := r.Intn(100) + this.FieldA = make([]float64, v199) + for i := 0; i < v199; i++ { + this.FieldA[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.FieldA[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v200 := r.Intn(100) + this.FieldB = make([]float32, v200) + for i := 0; i < v200; i++ { + this.FieldB[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.FieldB[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v201 := r.Intn(100) + this.FieldC = make([]int32, v201) + for i := 0; i < v201; i++ { + this.FieldC[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldC[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v202 := r.Intn(100) + this.FieldD = make([]int64, v202) + for i := 0; i < v202; i++ { + this.FieldD[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldD[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v203 := r.Intn(100) + this.FieldE = make([]uint32, v203) + for i := 0; i < v203; i++ { + this.FieldE[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v204 := r.Intn(100) + this.FieldF = make([]uint64, v204) + for i := 0; i < v204; i++ { + this.FieldF[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v205 := r.Intn(100) + this.FieldG = make([]int32, v205) + for i := 0; i < v205; i++ { + this.FieldG[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldG[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v206 := r.Intn(100) + this.FieldH = make([]int64, v206) + for i := 0; i < v206; i++ { + this.FieldH[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldH[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v207 := r.Intn(100) + this.FieldI = make([]uint32, v207) + for i := 0; i < v207; i++ { + this.FieldI[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v208 := r.Intn(100) + this.FieldJ = make([]int32, v208) + for i := 0; i < v208; i++ { + this.FieldJ[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldJ[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v209 := r.Intn(100) + this.FieldK = make([]uint64, v209) + for i := 0; i < v209; i++ { + this.FieldK[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v210 := r.Intn(100) + this.FieldL = make([]int64, v210) + for i := 0; i < v210; i++ { + this.FieldL[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldL[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v211 := r.Intn(100) + this.FieldM = make([]bool, v211) + for i := 0; i < v211; i++ { + this.FieldM[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v212 := r.Intn(10) + this.FieldN = make([]string, v212) + for i := 0; i < v212; i++ { + this.FieldN[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v213 := r.Intn(100) + this.FieldO = make([][]byte, v213) + for i := 0; i < v213; i++ { + v214 := r.Intn(100) + this.FieldO[i] = make([]byte, v214) + for j := 0; j < v214; j++ { + this.FieldO[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinStruct(r randyThetest, easy bool) *CustomNameNinStruct { + this := &CustomNameNinStruct{} + if r.Intn(10) != 0 { + v215 := float64(r.Float64()) + if r.Intn(2) == 0 { + v215 *= -1 + } + this.FieldA = &v215 + } + if r.Intn(10) != 0 { + v216 := float32(r.Float32()) + if r.Intn(2) == 0 { + v216 *= -1 + } + this.FieldB = &v216 + } + if r.Intn(10) != 0 { + this.FieldC = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v217 := r.Intn(10) + this.FieldD = make([]*NinOptNative, v217) + for i := 0; i < v217; i++ { + this.FieldD[i] = NewPopulatedNinOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v218 := uint64(uint64(r.Uint32())) + this.FieldE = &v218 + } + if r.Intn(10) != 0 { + v219 := int32(r.Int31()) + if r.Intn(2) == 0 { + v219 *= -1 + } + this.FieldF = &v219 + } + if r.Intn(10) != 0 { + this.FieldG = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v220 := bool(bool(r.Intn(2) == 0)) + this.FieldH = &v220 + } + if r.Intn(10) != 0 { + v221 := randStringThetest(r) + this.FieldI = &v221 + } + if r.Intn(10) != 0 { + v222 := r.Intn(100) + this.FieldJ = make([]byte, v222) + for i := 0; i < v222; i++ { + this.FieldJ[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameCustomType(r randyThetest, easy bool) *CustomNameCustomType { + this := &CustomNameCustomType{} + if r.Intn(10) != 0 { + this.FieldA = NewPopulatedUuid(r) + } + if r.Intn(10) != 0 { + this.FieldB = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + } + if r.Intn(10) != 0 { + v223 := r.Intn(10) + this.FieldC = make([]Uuid, v223) + for i := 0; i < v223; i++ { + v224 := NewPopulatedUuid(r) + this.FieldC[i] = *v224 + } + } + if r.Intn(10) != 0 { + v225 := r.Intn(10) + this.FieldD = make([]github_com_gogo_protobuf_test_custom.Uint128, v225) + for i := 0; i < v225; i++ { + v226 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.FieldD[i] = *v226 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 5) + } + return this +} + +func NewPopulatedCustomNameNinEmbeddedStructUnion(r randyThetest, easy bool) *CustomNameNinEmbeddedStructUnion { + this := &CustomNameNinEmbeddedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + case 1: + this.FieldA = NewPopulatedNinOptNative(r, easy) + case 2: + v227 := bool(bool(r.Intn(2) == 0)) + this.FieldB = &v227 + } + return this +} + +func NewPopulatedCustomNameEnum(r randyThetest, easy bool) *CustomNameEnum { + this := &CustomNameEnum{} + if r.Intn(10) != 0 { + v228 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.FieldA = &v228 + } + if r.Intn(10) != 0 { + v229 := r.Intn(10) + this.FieldB = make([]TheTestEnum, v229) + for i := 0; i < v229; i++ { + this.FieldB[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNoExtensionsMap(r randyThetest, easy bool) *NoExtensionsMap { + this := &NoExtensionsMap{} + if r.Intn(10) != 0 { + v230 := int64(r.Int63()) + if r.Intn(2) == 0 { + v230 *= -1 + } + this.Field1 = &v230 + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + fieldNumber := r.Intn(100) + 100 + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 201) + } + return this +} + +func NewPopulatedUnrecognized(r randyThetest, easy bool) *Unrecognized { + this := &Unrecognized{} + if r.Intn(10) != 0 { + v231 := randStringThetest(r) + this.Field1 = &v231 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedUnrecognizedWithInner(r randyThetest, easy bool) *UnrecognizedWithInner { + this := &UnrecognizedWithInner{} + if r.Intn(10) != 0 { + v232 := r.Intn(10) + this.Embedded = make([]*UnrecognizedWithInner_Inner, v232) + for i := 0; i < v232; i++ { + this.Embedded[i] = NewPopulatedUnrecognizedWithInner_Inner(r, easy) + } + } + if r.Intn(10) != 0 { + v233 := randStringThetest(r) + this.Field2 = &v233 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedUnrecognizedWithInner_Inner(r randyThetest, easy bool) *UnrecognizedWithInner_Inner { + this := &UnrecognizedWithInner_Inner{} + if r.Intn(10) != 0 { + v234 := uint32(r.Uint32()) + this.Field1 = &v234 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedUnrecognizedWithEmbed(r randyThetest, easy bool) *UnrecognizedWithEmbed { + this := &UnrecognizedWithEmbed{} + v235 := NewPopulatedUnrecognizedWithEmbed_Embedded(r, easy) + this.UnrecognizedWithEmbed_Embedded = *v235 + if r.Intn(10) != 0 { + v236 := randStringThetest(r) + this.Field2 = &v236 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedUnrecognizedWithEmbed_Embedded(r randyThetest, easy bool) *UnrecognizedWithEmbed_Embedded { + this := &UnrecognizedWithEmbed_Embedded{} + if r.Intn(10) != 0 { + v237 := uint32(r.Uint32()) + this.Field1 = &v237 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +type randyThetest interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneThetest(r randyThetest) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringThetest(r randyThetest) string { + v238 := r.Intn(100) + tmps := make([]rune, v238) + for i := 0; i < v238; i++ { + tmps[i] = randUTF8RuneThetest(r) + } + return string(tmps) +} +func randUnrecognizedThetest(r randyThetest, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldThetest(data, r, fieldNumber, wire) + } + return data +} +func randFieldThetest(data []byte, r randyThetest, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateThetest(data, uint64(key)) + v239 := r.Int63() + if r.Intn(2) == 0 { + v239 *= -1 + } + data = encodeVarintPopulateThetest(data, uint64(v239)) + case 1: + data = encodeVarintPopulateThetest(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateThetest(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateThetest(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateThetest(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateThetest(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *NidOptNative) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + n += 1 + sovThetest(uint64(m.Field3)) + n += 1 + sovThetest(uint64(m.Field4)) + n += 1 + sovThetest(uint64(m.Field5)) + n += 1 + sovThetest(uint64(m.Field6)) + n += 1 + sozThetest(uint64(m.Field7)) + n += 1 + sozThetest(uint64(m.Field8)) + n += 5 + n += 5 + n += 9 + n += 9 + n += 2 + l = len(m.Field14) + n += 1 + l + sovThetest(uint64(l)) + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNative) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + n += 1 + sozThetest(uint64(*m.Field8)) + } + if m.Field9 != nil { + n += 5 + } + if m.Field10 != nil { + n += 5 + } + if m.Field11 != nil { + n += 9 + } + if m.Field12 != nil { + n += 9 + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field5) > 0 { + for _, e := range m.Field5 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field9) > 0 { + n += 5 * len(m.Field9) + } + if len(m.Field10) > 0 { + n += 5 * len(m.Field10) + } + if len(m.Field11) > 0 { + n += 9 * len(m.Field11) + } + if len(m.Field12) > 0 { + n += 9 * len(m.Field12) + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field5) > 0 { + for _, e := range m.Field5 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field9) > 0 { + n += 5 * len(m.Field9) + } + if len(m.Field10) > 0 { + n += 5 * len(m.Field10) + } + if len(m.Field11) > 0 { + n += 9 * len(m.Field11) + } + if len(m.Field12) > 0 { + n += 9 * len(m.Field12) + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepPackedNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 1 + sovThetest(uint64(len(m.Field1)*8)) + len(m.Field1)*8 + } + if len(m.Field2) > 0 { + n += 1 + sovThetest(uint64(len(m.Field2)*4)) + len(m.Field2)*4 + } + if len(m.Field3) > 0 { + l = 0 + for _, e := range m.Field3 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field4) > 0 { + l = 0 + for _, e := range m.Field4 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field5) > 0 { + l = 0 + for _, e := range m.Field5 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field6) > 0 { + l = 0 + for _, e := range m.Field6 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field7) > 0 { + l = 0 + for _, e := range m.Field7 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field8) > 0 { + l = 0 + for _, e := range m.Field8 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field9) > 0 { + n += 1 + sovThetest(uint64(len(m.Field9)*4)) + len(m.Field9)*4 + } + if len(m.Field10) > 0 { + n += 1 + sovThetest(uint64(len(m.Field10)*4)) + len(m.Field10)*4 + } + if len(m.Field11) > 0 { + n += 1 + sovThetest(uint64(len(m.Field11)*8)) + len(m.Field11)*8 + } + if len(m.Field12) > 0 { + n += 1 + sovThetest(uint64(len(m.Field12)*8)) + len(m.Field12)*8 + } + if len(m.Field13) > 0 { + n += 1 + sovThetest(uint64(len(m.Field13))) + len(m.Field13)*1 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepPackedNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 1 + sovThetest(uint64(len(m.Field1)*8)) + len(m.Field1)*8 + } + if len(m.Field2) > 0 { + n += 1 + sovThetest(uint64(len(m.Field2)*4)) + len(m.Field2)*4 + } + if len(m.Field3) > 0 { + l = 0 + for _, e := range m.Field3 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field4) > 0 { + l = 0 + for _, e := range m.Field4 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field5) > 0 { + l = 0 + for _, e := range m.Field5 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field6) > 0 { + l = 0 + for _, e := range m.Field6 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field7) > 0 { + l = 0 + for _, e := range m.Field7 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field8) > 0 { + l = 0 + for _, e := range m.Field8 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field9) > 0 { + n += 1 + sovThetest(uint64(len(m.Field9)*4)) + len(m.Field9)*4 + } + if len(m.Field10) > 0 { + n += 1 + sovThetest(uint64(len(m.Field10)*4)) + len(m.Field10)*4 + } + if len(m.Field11) > 0 { + n += 1 + sovThetest(uint64(len(m.Field11)*8)) + len(m.Field11)*8 + } + if len(m.Field12) > 0 { + n += 1 + sovThetest(uint64(len(m.Field12)*8)) + len(m.Field12)*8 + } + if len(m.Field13) > 0 { + n += 1 + sovThetest(uint64(len(m.Field13))) + len(m.Field13)*1 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptStruct) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + n += 1 + sovThetest(uint64(m.Field6)) + n += 1 + sozThetest(uint64(m.Field7)) + l = m.Field8.Size() + n += 1 + l + sovThetest(uint64(l)) + n += 2 + l = len(m.Field14) + n += 1 + l + sovThetest(uint64(l)) + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptStruct) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field4 != nil { + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + l = m.Field8.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepStruct) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepStruct) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidEmbeddedStruct) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + n += 3 + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinEmbeddedStruct) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field200 != nil { + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.Field210 != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidNestedStruct) Size() (n int) { + var l int + _ = l + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + if len(m.Field2) > 0 { + for _, e := range m.Field2 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinNestedStruct) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.Field2) > 0 { + for _, e := range m.Field2 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptCustom) Size() (n int) { + var l int + _ = l + l = m.Id.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomDash) Size() (n int) { + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptCustom) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepCustom) Size() (n int) { + var l int + _ = l + if len(m.Id) > 0 { + for _, e := range m.Id { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Value) > 0 { + for _, e := range m.Value { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepCustom) Size() (n int) { + var l int + _ = l + if len(m.Id) > 0 { + for _, e := range m.Id { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Value) > 0 { + for _, e := range m.Value { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNativeUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptStructUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field4 != nil { + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinEmbeddedStructUnion) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field200 != nil { + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.Field210 != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinNestedStructUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field2 != nil { + l = m.Field2.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Tree) Size() (n int) { + var l int + _ = l + if m.Or != nil { + l = m.Or.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.And != nil { + l = m.And.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Leaf != nil { + l = m.Leaf.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *OrBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AndBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Leaf) Size() (n int) { + var l int + _ = l + n += 1 + sovThetest(uint64(m.Value)) + l = len(m.StrValue) + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DeepTree) Size() (n int) { + var l int + _ = l + if m.Down != nil { + l = m.Down.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.And != nil { + l = m.And.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Leaf != nil { + l = m.Leaf.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ADeepBranch) Size() (n int) { + var l int + _ = l + l = m.Down.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AndDeepBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DeepLeaf) Size() (n int) { + var l int + _ = l + l = m.Tree.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Nil) Size() (n int) { + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptEnum) Size() (n int) { + var l int + _ = l + n += 1 + sovThetest(uint64(m.Field1)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptEnum) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepEnum) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + for _, e := range m.Field1 { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepEnum) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + for _, e := range m.Field1 { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptEnumDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AnotherNinOptEnum) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AnotherNinOptEnumDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Timer) Size() (n int) { + var l int + _ = l + n += 9 + n += 9 + if m.Data != nil { + l = len(m.Data) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *MyExtendable) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + n += github_com_gogo_protobuf_proto.SizeOfExtensionMap(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *OtherExtenable) Size() (n int) { + var l int + _ = l + if m.M != nil { + l = m.M.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field2 != nil { + n += 1 + sovThetest(uint64(*m.Field2)) + } + if m.Field13 != nil { + n += 1 + sovThetest(uint64(*m.Field13)) + } + if m.XXX_extensions != nil { + n += github_com_gogo_protobuf_proto.SizeOfExtensionMap(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.EnumField != nil { + n += 1 + sovThetest(uint64(*m.EnumField)) + } + if m.NNM != nil { + l = m.NNM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.NM != nil { + l = m.NM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition_NestedMessage) Size() (n int) { + var l int + _ = l + if m.NestedField1 != nil { + n += 9 + } + if m.NNM != nil { + l = m.NNM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Size() (n int) { + var l int + _ = l + if m.NestedNestedField1 != nil { + l = len(*m.NestedNestedField1) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedScope) Size() (n int) { + var l int + _ = l + if m.A != nil { + l = m.A.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.B != nil { + n += 1 + sovThetest(uint64(*m.B)) + } + if m.C != nil { + l = m.C.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNativeDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + n += 1 + sozThetest(uint64(*m.Field8)) + } + if m.Field9 != nil { + n += 5 + } + if m.Field10 != nil { + n += 5 + } + if m.Field11 != nil { + n += 9 + } + if m.Field12 != nil { + n += 9 + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomContainer) Size() (n int) { + var l int + _ = l + l = m.CustomStruct.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNidOptNative) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + n += 1 + sovThetest(uint64(m.FieldC)) + n += 1 + sovThetest(uint64(m.FieldD)) + n += 1 + sovThetest(uint64(m.FieldE)) + n += 1 + sovThetest(uint64(m.FieldF)) + n += 1 + sozThetest(uint64(m.FieldG)) + n += 1 + sozThetest(uint64(m.FieldH)) + n += 5 + n += 5 + n += 9 + n += 9 + n += 2 + l = len(m.FieldN) + n += 1 + l + sovThetest(uint64(l)) + if m.FieldO != nil { + l = len(m.FieldO) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinOptNative) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 9 + } + if m.FieldB != nil { + n += 5 + } + if m.FieldC != nil { + n += 1 + sovThetest(uint64(*m.FieldC)) + } + if m.FieldD != nil { + n += 1 + sovThetest(uint64(*m.FieldD)) + } + if m.FieldE != nil { + n += 1 + sovThetest(uint64(*m.FieldE)) + } + if m.FieldF != nil { + n += 1 + sovThetest(uint64(*m.FieldF)) + } + if m.FieldG != nil { + n += 1 + sozThetest(uint64(*m.FieldG)) + } + if m.FieldH != nil { + n += 1 + sozThetest(uint64(*m.FieldH)) + } + if m.FieldI != nil { + n += 5 + } + if m.FieldJ != nil { + n += 5 + } + if m.FieldK != nil { + n += 9 + } + if m.FielL != nil { + n += 9 + } + if m.FieldM != nil { + n += 2 + } + if m.FieldN != nil { + l = len(*m.FieldN) + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldO != nil { + l = len(m.FieldO) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinRepNative) Size() (n int) { + var l int + _ = l + if len(m.FieldA) > 0 { + n += 9 * len(m.FieldA) + } + if len(m.FieldB) > 0 { + n += 5 * len(m.FieldB) + } + if len(m.FieldC) > 0 { + for _, e := range m.FieldC { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldE) > 0 { + for _, e := range m.FieldE { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldF) > 0 { + for _, e := range m.FieldF { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldG) > 0 { + for _, e := range m.FieldG { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.FieldH) > 0 { + for _, e := range m.FieldH { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.FieldI) > 0 { + n += 5 * len(m.FieldI) + } + if len(m.FieldJ) > 0 { + n += 5 * len(m.FieldJ) + } + if len(m.FieldK) > 0 { + n += 9 * len(m.FieldK) + } + if len(m.FieldL) > 0 { + n += 9 * len(m.FieldL) + } + if len(m.FieldM) > 0 { + n += 2 * len(m.FieldM) + } + if len(m.FieldN) > 0 { + for _, s := range m.FieldN { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.FieldO) > 0 { + for _, b := range m.FieldO { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinStruct) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 9 + } + if m.FieldB != nil { + n += 5 + } + if m.FieldC != nil { + l = m.FieldC.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.FieldE != nil { + n += 1 + sovThetest(uint64(*m.FieldE)) + } + if m.FieldF != nil { + n += 1 + sozThetest(uint64(*m.FieldF)) + } + if m.FieldG != nil { + l = m.FieldG.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldH != nil { + n += 2 + } + if m.FieldI != nil { + l = len(*m.FieldI) + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldJ != nil { + l = len(m.FieldJ) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameCustomType) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + l = m.FieldA.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldB != nil { + l = m.FieldB.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.FieldC) > 0 { + for _, e := range m.FieldC { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinEmbeddedStructUnion) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldA != nil { + l = m.FieldA.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.FieldB != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameEnum) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 1 + sovThetest(uint64(*m.FieldA)) + } + if len(m.FieldB) > 0 { + for _, e := range m.FieldB { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NoExtensionsMap) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + n += len(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Unrecognized) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = len(*m.Field1) + n += 1 + l + sovThetest(uint64(l)) + } + return n +} + +func (m *UnrecognizedWithInner) Size() (n int) { + var l int + _ = l + if len(m.Embedded) > 0 { + for _, e := range m.Embedded { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.Field2 != nil { + l = len(*m.Field2) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UnrecognizedWithInner_Inner) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + return n +} + +func (m *UnrecognizedWithEmbed) Size() (n int) { + var l int + _ = l + l = m.UnrecognizedWithEmbed_Embedded.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.Field2 != nil { + l = len(*m.Field2) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UnrecognizedWithEmbed_Embedded) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + return n +} + +func sovThetest(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozThetest(x uint64) (n int) { + return sovThetest(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *NidOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNative{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + valueToStringThetest(this.Field8) + `,`, + `Field9:` + valueToStringThetest(this.Field9) + `,`, + `Field10:` + valueToStringThetest(this.Field10) + `,`, + `Field11:` + valueToStringThetest(this.Field11) + `,`, + `Field12:` + valueToStringThetest(this.Field12) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepPackedNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepPackedNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepPackedNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepPackedNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(strings.Replace(this.Field3.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field4:` + strings.Replace(strings.Replace(this.Field4.String(), "NinOptNative", "NinOptNative", 1), `&`, ``, 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(strings.Replace(this.Field8.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptStruct{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field4:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1), `&`, ``, 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidEmbeddedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidEmbeddedStruct{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(strings.Replace(this.Field200.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field210:` + fmt.Sprintf("%v", this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinEmbeddedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinEmbeddedStruct{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(fmt.Sprintf("%v", this.Field200), "NidOptNative", "NidOptNative", 1) + `,`, + `Field210:` + valueToStringThetest(this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidNestedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidNestedStruct{`, + `Field1:` + strings.Replace(strings.Replace(this.Field1.String(), "NidOptStruct", "NidOptStruct", 1), `&`, ``, 1) + `,`, + `Field2:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field2), "NidRepStruct", "NidRepStruct", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinNestedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinNestedStruct{`, + `Field1:` + strings.Replace(fmt.Sprintf("%v", this.Field1), "NinOptStruct", "NinOptStruct", 1) + `,`, + `Field2:` + strings.Replace(fmt.Sprintf("%v", this.Field2), "NinRepStruct", "NinRepStruct", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomDash) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomDash{`, + `Value:` + valueToStringThetest(this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptCustom{`, + `Id:` + valueToStringThetest(this.Id) + `,`, + `Value:` + valueToStringThetest(this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNativeUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNativeUnion{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptStructUnion{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinEmbeddedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinEmbeddedStructUnion{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(fmt.Sprintf("%v", this.Field200), "NinOptNative", "NinOptNative", 1) + `,`, + `Field210:` + valueToStringThetest(this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinNestedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinNestedStructUnion{`, + `Field1:` + strings.Replace(fmt.Sprintf("%v", this.Field1), "NinOptNativeUnion", "NinOptNativeUnion", 1) + `,`, + `Field2:` + strings.Replace(fmt.Sprintf("%v", this.Field2), "NinOptStructUnion", "NinOptStructUnion", 1) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NinEmbeddedStructUnion", "NinEmbeddedStructUnion", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Tree) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Tree{`, + `Or:` + strings.Replace(fmt.Sprintf("%v", this.Or), "OrBranch", "OrBranch", 1) + `,`, + `And:` + strings.Replace(fmt.Sprintf("%v", this.And), "AndBranch", "AndBranch", 1) + `,`, + `Leaf:` + strings.Replace(fmt.Sprintf("%v", this.Leaf), "Leaf", "Leaf", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OrBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OrBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AndBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AndBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Leaf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Leaf{`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `StrValue:` + fmt.Sprintf("%v", this.StrValue) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *DeepTree) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DeepTree{`, + `Down:` + strings.Replace(fmt.Sprintf("%v", this.Down), "ADeepBranch", "ADeepBranch", 1) + `,`, + `And:` + strings.Replace(fmt.Sprintf("%v", this.And), "AndDeepBranch", "AndDeepBranch", 1) + `,`, + `Leaf:` + strings.Replace(fmt.Sprintf("%v", this.Leaf), "DeepLeaf", "DeepLeaf", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ADeepBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ADeepBranch{`, + `Down:` + strings.Replace(strings.Replace(this.Down.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AndDeepBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AndDeepBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *DeepLeaf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DeepLeaf{`, + `Tree:` + strings.Replace(strings.Replace(this.Tree.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Nil) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Nil{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptEnum{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptEnumDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptEnumDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AnotherNinOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnotherNinOptEnum{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AnotherNinOptEnumDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnotherNinOptEnumDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Timer) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Timer{`, + `Time1:` + fmt.Sprintf("%v", this.Time1) + `,`, + `Time2:` + fmt.Sprintf("%v", this.Time2) + `,`, + `Data:` + fmt.Sprintf("%v", this.Data) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *MyExtendable) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&MyExtendable{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsMap(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OtherExtenable) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OtherExtenable{`, + `M:` + strings.Replace(fmt.Sprintf("%v", this.M), "MyExtendable", "MyExtendable", 1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsMap(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `EnumField:` + valueToStringThetest(this.EnumField) + `,`, + `NNM:` + strings.Replace(fmt.Sprintf("%v", this.NNM), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `NM:` + strings.Replace(fmt.Sprintf("%v", this.NM), "NestedDefinition_NestedMessage", "NestedDefinition_NestedMessage", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition_NestedMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition_NestedMessage{`, + `NestedField1:` + valueToStringThetest(this.NestedField1) + `,`, + `NNM:` + strings.Replace(fmt.Sprintf("%v", this.NNM), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition_NestedMessage_NestedNestedMsg{`, + `NestedNestedField1:` + valueToStringThetest(this.NestedNestedField1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedScope) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedScope{`, + `A:` + strings.Replace(fmt.Sprintf("%v", this.A), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `B:` + valueToStringThetest(this.B) + `,`, + `C:` + strings.Replace(fmt.Sprintf("%v", this.C), "NestedDefinition_NestedMessage", "NestedDefinition_NestedMessage", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNativeDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNativeDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + valueToStringThetest(this.Field8) + `,`, + `Field9:` + valueToStringThetest(this.Field9) + `,`, + `Field10:` + valueToStringThetest(this.Field10) + `,`, + `Field11:` + valueToStringThetest(this.Field11) + `,`, + `Field12:` + valueToStringThetest(this.Field12) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomContainer) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomContainer{`, + `CustomStruct:` + strings.Replace(strings.Replace(this.CustomStruct.String(), "NidOptCustom", "NidOptCustom", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNidOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNidOptNative{`, + `FieldA:` + fmt.Sprintf("%v", this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `FieldE:` + fmt.Sprintf("%v", this.FieldE) + `,`, + `FieldF:` + fmt.Sprintf("%v", this.FieldF) + `,`, + `FieldG:` + fmt.Sprintf("%v", this.FieldG) + `,`, + `FieldH:` + fmt.Sprintf("%v", this.FieldH) + `,`, + `FieldI:` + fmt.Sprintf("%v", this.FieldI) + `,`, + `FieldJ:` + fmt.Sprintf("%v", this.FieldJ) + `,`, + `FieldK:` + fmt.Sprintf("%v", this.FieldK) + `,`, + `FieldL:` + fmt.Sprintf("%v", this.FieldL) + `,`, + `FieldM:` + fmt.Sprintf("%v", this.FieldM) + `,`, + `FieldN:` + fmt.Sprintf("%v", this.FieldN) + `,`, + `FieldO:` + fmt.Sprintf("%v", this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinOptNative{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + valueToStringThetest(this.FieldC) + `,`, + `FieldD:` + valueToStringThetest(this.FieldD) + `,`, + `FieldE:` + valueToStringThetest(this.FieldE) + `,`, + `FieldF:` + valueToStringThetest(this.FieldF) + `,`, + `FieldG:` + valueToStringThetest(this.FieldG) + `,`, + `FieldH:` + valueToStringThetest(this.FieldH) + `,`, + `FieldI:` + valueToStringThetest(this.FieldI) + `,`, + `FieldJ:` + valueToStringThetest(this.FieldJ) + `,`, + `FieldK:` + valueToStringThetest(this.FieldK) + `,`, + `FielL:` + valueToStringThetest(this.FielL) + `,`, + `FieldM:` + valueToStringThetest(this.FieldM) + `,`, + `FieldN:` + valueToStringThetest(this.FieldN) + `,`, + `FieldO:` + valueToStringThetest(this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinRepNative{`, + `FieldA:` + fmt.Sprintf("%v", this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `FieldE:` + fmt.Sprintf("%v", this.FieldE) + `,`, + `FieldF:` + fmt.Sprintf("%v", this.FieldF) + `,`, + `FieldG:` + fmt.Sprintf("%v", this.FieldG) + `,`, + `FieldH:` + fmt.Sprintf("%v", this.FieldH) + `,`, + `FieldI:` + fmt.Sprintf("%v", this.FieldI) + `,`, + `FieldJ:` + fmt.Sprintf("%v", this.FieldJ) + `,`, + `FieldK:` + fmt.Sprintf("%v", this.FieldK) + `,`, + `FieldL:` + fmt.Sprintf("%v", this.FieldL) + `,`, + `FieldM:` + fmt.Sprintf("%v", this.FieldM) + `,`, + `FieldN:` + fmt.Sprintf("%v", this.FieldN) + `,`, + `FieldO:` + fmt.Sprintf("%v", this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinStruct{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + strings.Replace(fmt.Sprintf("%v", this.FieldC), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldD:` + strings.Replace(fmt.Sprintf("%v", this.FieldD), "NinOptNative", "NinOptNative", 1) + `,`, + `FieldE:` + valueToStringThetest(this.FieldE) + `,`, + `FieldF:` + valueToStringThetest(this.FieldF) + `,`, + `FieldG:` + strings.Replace(fmt.Sprintf("%v", this.FieldG), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldH:` + valueToStringThetest(this.FieldH) + `,`, + `FieldI:` + valueToStringThetest(this.FieldI) + `,`, + `FieldJ:` + valueToStringThetest(this.FieldJ) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameCustomType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameCustomType{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinEmbeddedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinEmbeddedStructUnion{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldA:` + strings.Replace(fmt.Sprintf("%v", this.FieldA), "NinOptNative", "NinOptNative", 1) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameEnum{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NoExtensionsMap) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NoExtensionsMap{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsBytes(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Unrecognized) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Unrecognized{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithInner) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithInner{`, + `Embedded:` + strings.Replace(fmt.Sprintf("%v", this.Embedded), "UnrecognizedWithInner_Inner", "UnrecognizedWithInner_Inner", 1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithInner_Inner) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithInner_Inner{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithEmbed) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithEmbed{`, + `UnrecognizedWithEmbed_Embedded:` + strings.Replace(strings.Replace(this.UnrecognizedWithEmbed_Embedded.String(), "UnrecognizedWithEmbed_Embedded", "UnrecognizedWithEmbed_Embedded", 1), `&`, ``, 1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithEmbed_Embedded) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithEmbed_Embedded{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func valueToStringThetest(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (this *NinOptNativeUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + if this.Field4 != nil { + return this.Field4 + } + if this.Field5 != nil { + return this.Field5 + } + if this.Field6 != nil { + return this.Field6 + } + if this.Field13 != nil { + return this.Field13 + } + if this.Field14 != nil { + return this.Field14 + } + if this.Field15 != nil { + return this.Field15 + } + return nil +} + +func (this *NinOptNativeUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *float64: + this.Field1 = vt + case *float32: + this.Field2 = vt + case *int32: + this.Field3 = vt + case *int64: + this.Field4 = vt + case *uint32: + this.Field5 = vt + case *uint64: + this.Field6 = vt + case *bool: + this.Field13 = vt + case *string: + this.Field14 = vt + case []byte: + this.Field15 = vt + default: + return false + } + return true +} +func (this *NinOptStructUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + if this.Field4 != nil { + return this.Field4 + } + if this.Field6 != nil { + return this.Field6 + } + if this.Field7 != nil { + return this.Field7 + } + if this.Field13 != nil { + return this.Field13 + } + if this.Field14 != nil { + return this.Field14 + } + if this.Field15 != nil { + return this.Field15 + } + return nil +} + +func (this *NinOptStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *float64: + this.Field1 = vt + case *float32: + this.Field2 = vt + case *NidOptNative: + this.Field3 = vt + case *NinOptNative: + this.Field4 = vt + case *uint64: + this.Field6 = vt + case *int32: + this.Field7 = vt + case *bool: + this.Field13 = vt + case *string: + this.Field14 = vt + case []byte: + this.Field15 = vt + default: + return false + } + return true +} +func (this *NinEmbeddedStructUnion) GetValue() interface{} { + if this.NidOptNative != nil { + return this.NidOptNative + } + if this.Field200 != nil { + return this.Field200 + } + if this.Field210 != nil { + return this.Field210 + } + return nil +} + +func (this *NinEmbeddedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NidOptNative: + this.NidOptNative = vt + case *NinOptNative: + this.Field200 = vt + case *bool: + this.Field210 = vt + default: + return false + } + return true +} +func (this *NinNestedStructUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + return nil +} + +func (this *NinNestedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NinOptNativeUnion: + this.Field1 = vt + case *NinOptStructUnion: + this.Field2 = vt + case *NinEmbeddedStructUnion: + this.Field3 = vt + default: + this.Field1 = new(NinOptNativeUnion) + if set := this.Field1.SetValue(value); set { + return true + } + this.Field1 = nil + this.Field2 = new(NinOptStructUnion) + if set := this.Field2.SetValue(value); set { + return true + } + this.Field2 = nil + this.Field3 = new(NinEmbeddedStructUnion) + if set := this.Field3.SetValue(value); set { + return true + } + this.Field3 = nil + return false + } + return true +} +func (this *Tree) GetValue() interface{} { + if this.Or != nil { + return this.Or + } + if this.And != nil { + return this.And + } + if this.Leaf != nil { + return this.Leaf + } + return nil +} + +func (this *Tree) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *OrBranch: + this.Or = vt + case *AndBranch: + this.And = vt + case *Leaf: + this.Leaf = vt + default: + return false + } + return true +} +func (this *DeepTree) GetValue() interface{} { + if this.Down != nil { + return this.Down + } + if this.And != nil { + return this.And + } + if this.Leaf != nil { + return this.Leaf + } + return nil +} + +func (this *DeepTree) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *ADeepBranch: + this.Down = vt + case *AndDeepBranch: + this.And = vt + case *DeepLeaf: + this.Leaf = vt + default: + return false + } + return true +} +func (this *CustomNameNinEmbeddedStructUnion) GetValue() interface{} { + if this.NidOptNative != nil { + return this.NidOptNative + } + if this.FieldA != nil { + return this.FieldA + } + if this.FieldB != nil { + return this.FieldB + } + return nil +} + +func (this *CustomNameNinEmbeddedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NidOptNative: + this.NidOptNative = vt + case *NinOptNative: + this.FieldA = vt + case *bool: + this.FieldB = vt + default: + return false + } + return true +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/marshaler/thetest.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/marshaler/thetest.proto new file mode 100644 index 0000000000000000000000000000000000000000..f427444140753706ba63294e0e086ec5e8642fcc --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/marshaler/thetest.proto @@ -0,0 +1,584 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package test; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message NidOptNative { + optional double Field1 = 1 [(gogoproto.nullable) = false]; + optional float Field2 = 2 [(gogoproto.nullable) = false]; + optional int32 Field3 = 3 [(gogoproto.nullable) = false]; + optional int64 Field4 = 4 [(gogoproto.nullable) = false]; + optional uint32 Field5 = 5 [(gogoproto.nullable) = false]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false]; + optional sint64 Field8 = 8 [(gogoproto.nullable) = false]; + optional fixed32 Field9 = 9 [(gogoproto.nullable) = false]; + optional sfixed32 Field10 = 10 [(gogoproto.nullable) = false]; + optional fixed64 Field11 = 11 [(gogoproto.nullable) = false]; + optional sfixed64 Field12 = 12 [(gogoproto.nullable) = false]; + optional bool Field13 = 13 [(gogoproto.nullable) = false]; + optional string Field14 = 14 [(gogoproto.nullable) = false]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinOptNative { + optional double Field1 = 1; + optional float Field2 = 2; + optional int32 Field3 = 3; + optional int64 Field4 = 4; + optional uint32 Field5 = 5; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional sint64 Field8 = 8; + optional fixed32 Field9 = 9; + optional sfixed32 Field10 = 10; + optional fixed64 Field11 = 11; + optional sfixed64 Field12 = 12; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NidRepNative { + repeated double Field1 = 1 [(gogoproto.nullable) = false]; + repeated float Field2 = 2 [(gogoproto.nullable) = false]; + repeated int32 Field3 = 3 [(gogoproto.nullable) = false]; + repeated int64 Field4 = 4 [(gogoproto.nullable) = false]; + repeated uint32 Field5 = 5 [(gogoproto.nullable) = false]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false]; + repeated sint64 Field8 = 8 [(gogoproto.nullable) = false]; + repeated fixed32 Field9 = 9 [(gogoproto.nullable) = false]; + repeated sfixed32 Field10 = 10 [(gogoproto.nullable) = false]; + repeated fixed64 Field11 = 11 [(gogoproto.nullable) = false]; + repeated sfixed64 Field12 = 12 [(gogoproto.nullable) = false]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false]; + repeated string Field14 = 14 [(gogoproto.nullable) = false]; + repeated bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinRepNative { + repeated double Field1 = 1; + repeated float Field2 = 2; + repeated int32 Field3 = 3; + repeated int64 Field4 = 4; + repeated uint32 Field5 = 5; + repeated uint64 Field6 = 6; + repeated sint32 Field7 = 7; + repeated sint64 Field8 = 8; + repeated fixed32 Field9 = 9; + repeated sfixed32 Field10 = 10; + repeated fixed64 Field11 = 11; + repeated sfixed64 Field12 = 12; + repeated bool Field13 = 13; + repeated string Field14 = 14; + repeated bytes Field15 = 15; +} + +message NidRepPackedNative { + repeated double Field1 = 1 [(gogoproto.nullable) = false, packed = true]; + repeated float Field2 = 2 [(gogoproto.nullable) = false, packed = true]; + repeated int32 Field3 = 3 [(gogoproto.nullable) = false, packed = true]; + repeated int64 Field4 = 4 [(gogoproto.nullable) = false, packed = true]; + repeated uint32 Field5 = 5 [(gogoproto.nullable) = false, packed = true]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false, packed = true]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false, packed = true]; + repeated sint64 Field8 = 8 [(gogoproto.nullable) = false, packed = true]; + repeated fixed32 Field9 = 9 [(gogoproto.nullable) = false, packed = true]; + repeated sfixed32 Field10 = 10 [(gogoproto.nullable) = false, packed = true]; + repeated fixed64 Field11 = 11 [(gogoproto.nullable) = false, packed = true]; + repeated sfixed64 Field12 = 12 [(gogoproto.nullable) = false, packed = true]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false, packed = true]; +} + +message NinRepPackedNative { + repeated double Field1 = 1 [packed = true]; + repeated float Field2 = 2 [packed = true]; + repeated int32 Field3 = 3 [packed = true]; + repeated int64 Field4 = 4 [packed = true]; + repeated uint32 Field5 = 5 [packed = true]; + repeated uint64 Field6 = 6 [packed = true]; + repeated sint32 Field7 = 7 [packed = true]; + repeated sint64 Field8 = 8 [packed = true]; + repeated fixed32 Field9 = 9 [packed = true]; + repeated sfixed32 Field10 = 10 [packed = true]; + repeated fixed64 Field11 = 11 [packed = true]; + repeated sfixed64 Field12 = 12 [packed = true]; + repeated bool Field13 = 13 [packed = true]; +} + +message NidOptStruct { + optional double Field1 = 1 [(gogoproto.nullable) = false]; + optional float Field2 = 2 [(gogoproto.nullable) = false]; + optional NidOptNative Field3 = 3 [(gogoproto.nullable) = false]; + optional NinOptNative Field4 = 4 [(gogoproto.nullable) = false]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false]; + optional NidOptNative Field8 = 8 [(gogoproto.nullable) = false]; + optional bool Field13 = 13 [(gogoproto.nullable) = false]; + optional string Field14 = 14 [(gogoproto.nullable) = false]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinOptStruct { + optional double Field1 = 1; + optional float Field2 = 2; + optional NidOptNative Field3 = 3; + optional NinOptNative Field4 = 4; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional NidOptNative Field8 = 8; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NidRepStruct { + repeated double Field1 = 1 [(gogoproto.nullable) = false]; + repeated float Field2 = 2 [(gogoproto.nullable) = false]; + repeated NidOptNative Field3 = 3 [(gogoproto.nullable) = false]; + repeated NinOptNative Field4 = 4 [(gogoproto.nullable) = false]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false]; + repeated NidOptNative Field8 = 8 [(gogoproto.nullable) = false]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false]; + repeated string Field14 = 14 [(gogoproto.nullable) = false]; + repeated bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinRepStruct { + repeated double Field1 = 1; + repeated float Field2 = 2; + repeated NidOptNative Field3 = 3; + repeated NinOptNative Field4 = 4; + repeated uint64 Field6 = 6; + repeated sint32 Field7 = 7; + repeated NidOptNative Field8 = 8; + repeated bool Field13 = 13; + repeated string Field14 = 14; + repeated bytes Field15 = 15; +} + +message NidEmbeddedStruct { + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NidOptNative Field200 = 200 [(gogoproto.nullable) = false]; + optional bool Field210 = 210 [(gogoproto.nullable) = false]; +} + +message NinEmbeddedStruct { + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NidOptNative Field200 = 200; + optional bool Field210 = 210; +} + +message NidNestedStruct { + optional NidOptStruct Field1 = 1 [(gogoproto.nullable) = false]; + repeated NidRepStruct Field2 = 2 [(gogoproto.nullable) = false]; +} + +message NinNestedStruct { + optional NinOptStruct Field1 = 1; + repeated NinRepStruct Field2 = 2; +} + +message NidOptCustom { + optional bytes Id = 1 [(gogoproto.customtype) = "Uuid", (gogoproto.nullable) = false]; + optional bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; +} + +message CustomDash { + optional bytes Value = 1 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom-dash-type.Bytes"]; +} + +message NinOptCustom { + optional bytes Id = 1 [(gogoproto.customtype) = "Uuid"]; + optional bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message NidRepCustom { + repeated bytes Id = 1 [(gogoproto.customtype) = "Uuid", (gogoproto.nullable) = false]; + repeated bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; +} + +message NinRepCustom { + repeated bytes Id = 1 [(gogoproto.customtype) = "Uuid"]; + repeated bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message NinOptNativeUnion { + option (gogoproto.onlyone) = true; + optional double Field1 = 1; + optional float Field2 = 2; + optional int32 Field3 = 3; + optional int64 Field4 = 4; + optional uint32 Field5 = 5; + optional uint64 Field6 = 6; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NinOptStructUnion { + option (gogoproto.onlyone) = true; + optional double Field1 = 1; + optional float Field2 = 2; + optional NidOptNative Field3 = 3; + optional NinOptNative Field4 = 4; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NinEmbeddedStructUnion { + option (gogoproto.onlyone) = true; + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NinOptNative Field200 = 200; + optional bool Field210 = 210; +} + +message NinNestedStructUnion { + option (gogoproto.onlyone) = true; + optional NinOptNativeUnion Field1 = 1; + optional NinOptStructUnion Field2 = 2; + optional NinEmbeddedStructUnion Field3 = 3; +} + +message Tree { + option (gogoproto.onlyone) = true; + optional OrBranch Or = 1; + optional AndBranch And = 2; + optional Leaf Leaf = 3; +} + +message OrBranch { + optional Tree Left = 1 [(gogoproto.nullable) = false]; + optional Tree Right = 2 [(gogoproto.nullable) = false]; +} + +message AndBranch { + optional Tree Left = 1 [(gogoproto.nullable) = false]; + optional Tree Right = 2 [(gogoproto.nullable) = false]; +} + +message Leaf { + optional int64 Value = 1 [(gogoproto.nullable) = false]; + optional string StrValue = 2 [(gogoproto.nullable) = false]; +} + +message DeepTree { + option (gogoproto.onlyone) = true; + optional ADeepBranch Down = 1; + optional AndDeepBranch And = 2; + optional DeepLeaf Leaf = 3; +} + +message ADeepBranch { + optional DeepTree Down = 2 [(gogoproto.nullable) = false]; +} + +message AndDeepBranch { + optional DeepTree Left = 1 [(gogoproto.nullable) = false]; + optional DeepTree Right = 2 [(gogoproto.nullable) = false]; +} + +message DeepLeaf { + optional Tree Tree = 1 [(gogoproto.nullable) = false]; +} + +message Nil { + +} + +enum TheTestEnum { + A = 0; + B = 1; + C = 2; +} + +message NidOptEnum { + optional TheTestEnum Field1 = 1 [(gogoproto.nullable) = false]; +} + +message NinOptEnum { + optional TheTestEnum Field1 = 1; +} + +message NidRepEnum { + repeated TheTestEnum Field1 = 1 [(gogoproto.nullable) = false]; +} + +message NinRepEnum { + repeated TheTestEnum Field1 = 1; +} + +message NinOptEnumDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional TheTestEnum Field1 = 1 [default=C]; +} + +enum AnotherTestEnum { + option (gogoproto.goproto_enum_prefix) = false; + D = 10; + E = 11; +} + +message AnotherNinOptEnum { + optional AnotherTestEnum Field1 = 1; +} + +message AnotherNinOptEnumDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional AnotherTestEnum Field1 = 1 [default=E]; +} + +message Timer { + optional sfixed64 Time1 = 1 [(gogoproto.nullable) = false]; + optional sfixed64 Time2 = 2 [(gogoproto.nullable) = false]; + optional bytes Data = 3 [(gogoproto.nullable) = false]; +} + +message MyExtendable { + option (gogoproto.face) = false; + optional int64 Field1 = 1; + extensions 100 to 199; +} + +extend MyExtendable { + optional double FieldA = 100; + optional NinOptNative FieldB = 101; + optional NinEmbeddedStruct FieldC = 102; +} + +message OtherExtenable { + option (gogoproto.face) = false; + optional int64 Field2 = 2; + extensions 14 to 16; + optional int64 Field13 = 13; + extensions 10 to 12; + optional MyExtendable M = 1; +} + +message NestedDefinition { + optional int64 Field1 = 1; + message NestedMessage { + optional fixed64 NestedField1 = 1; + optional NestedNestedMsg NNM = 2; + message NestedNestedMsg { + optional string NestedNestedField1 = 10; + } + } + enum NestedEnum { + TYPE_NESTED = 1; + } + optional NestedEnum EnumField = 2; + optional NestedMessage.NestedNestedMsg NNM = 3; + optional NestedMessage NM = 4; +} + +message NestedScope { + optional NestedDefinition.NestedMessage.NestedNestedMsg A = 1; + optional NestedDefinition.NestedEnum B = 2; + optional NestedDefinition.NestedMessage C = 3; +} + +message NinOptNativeDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional double Field1 = 1 [default = 1234.1234]; + optional float Field2 = 2 [default = 1234.1234]; + optional int32 Field3 = 3 [default = 1234]; + optional int64 Field4 = 4 [default = 1234]; + optional uint32 Field5 = 5 [default = 1234]; + optional uint64 Field6 = 6 [default = 1234]; + optional sint32 Field7 = 7 [default = 1234]; + optional sint64 Field8 = 8 [default = 1234]; + optional fixed32 Field9 = 9 [default = 1234]; + optional sfixed32 Field10 = 10 [default = 1234]; + optional fixed64 Field11 = 11 [default = 1234]; + optional sfixed64 Field12 = 12 [default = 1234]; + optional bool Field13 = 13 [default = true]; + optional string Field14 = 14 [default = "1234"]; + optional bytes Field15 = 15; +} + +message CustomContainer { + optional NidOptCustom CustomStruct = 1 [(gogoproto.nullable) = false]; +} + +message CustomNameNidOptNative { + optional double Field1 = 1 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldB"]; + optional int32 Field3 = 3 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldC"]; + optional int64 Field4 = 4 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldD"]; + optional uint32 Field5 = 5 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldE"]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldF"]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldG"]; + optional sint64 Field8 = 8 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldH"]; + optional fixed32 Field9 = 9 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldI"]; + optional sfixed32 Field10 = 10 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldJ"]; + optional fixed64 Field11 = 11 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldK"]; + optional sfixed64 Field12 = 12 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldL"]; + optional bool Field13 = 13 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldM"]; + optional string Field14 = 14 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldN"]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinOptNative { + optional double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + optional int32 Field3 = 3 [(gogoproto.customname) = "FieldC"]; + optional int64 Field4 = 4 [(gogoproto.customname) = "FieldD"]; + optional uint32 Field5 = 5 [(gogoproto.customname) = "FieldE"]; + optional uint64 Field6 = 6 [(gogoproto.customname) = "FieldF"]; + optional sint32 Field7 = 7 [(gogoproto.customname) = "FieldG"]; + optional sint64 Field8 = 8 [(gogoproto.customname) = "FieldH"]; + optional fixed32 Field9 = 9 [(gogoproto.customname) = "FieldI"]; + optional sfixed32 Field10 = 10 [(gogoproto.customname) = "FieldJ"]; + optional fixed64 Field11 = 11 [(gogoproto.customname) = "FieldK"]; + optional sfixed64 Field12 = 12 [(gogoproto.customname) = "FielL"]; + optional bool Field13 = 13 [(gogoproto.customname) = "FieldM"]; + optional string Field14 = 14 [(gogoproto.customname) = "FieldN"]; + optional bytes Field15 = 15 [(gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinRepNative { + repeated double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + repeated float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + repeated int32 Field3 = 3 [(gogoproto.customname) = "FieldC"]; + repeated int64 Field4 = 4 [(gogoproto.customname) = "FieldD"]; + repeated uint32 Field5 = 5 [(gogoproto.customname) = "FieldE"]; + repeated uint64 Field6 = 6 [(gogoproto.customname) = "FieldF"]; + repeated sint32 Field7 = 7 [(gogoproto.customname) = "FieldG"]; + repeated sint64 Field8 = 8 [(gogoproto.customname) = "FieldH"]; + repeated fixed32 Field9 = 9 [(gogoproto.customname) = "FieldI"]; + repeated sfixed32 Field10 = 10 [(gogoproto.customname) = "FieldJ"]; + repeated fixed64 Field11 = 11 [(gogoproto.customname) = "FieldK"]; + repeated sfixed64 Field12 = 12 [(gogoproto.customname) = "FieldL"]; + repeated bool Field13 = 13 [(gogoproto.customname) = "FieldM"]; + repeated string Field14 = 14 [(gogoproto.customname) = "FieldN"]; + repeated bytes Field15 = 15 [(gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinStruct { + optional double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + optional NidOptNative Field3 = 3 [(gogoproto.customname) = "FieldC"]; + repeated NinOptNative Field4 = 4 [(gogoproto.customname) = "FieldD"]; + optional uint64 Field6 = 6 [(gogoproto.customname) = "FieldE"]; + optional sint32 Field7 = 7 [(gogoproto.customname) = "FieldF"]; + optional NidOptNative Field8 = 8 [(gogoproto.customname) = "FieldG"]; + optional bool Field13 = 13 [(gogoproto.customname) = "FieldH"]; + optional string Field14 = 14 [(gogoproto.customname) = "FieldI"]; + optional bytes Field15 = 15 [(gogoproto.customname) = "FieldJ"]; +} + +message CustomNameCustomType { + optional bytes Id = 1 [(gogoproto.customname) = "FieldA", (gogoproto.customtype) = "Uuid"]; + optional bytes Value = 2 [(gogoproto.customname) = "FieldB", (gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; + repeated bytes Ids = 3 [(gogoproto.customname) = "FieldC", (gogoproto.customtype) = "Uuid"]; + repeated bytes Values = 4 [(gogoproto.customname) = "FieldD", (gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message CustomNameNinEmbeddedStructUnion { + option (gogoproto.onlyone) = true; + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NinOptNative Field200 = 200 [(gogoproto.customname) = "FieldA"]; + optional bool Field210 = 210 [(gogoproto.customname) = "FieldB"]; +} + +message CustomNameEnum { + optional TheTestEnum Field1 = 1 [(gogoproto.customname) = "FieldA"]; + repeated TheTestEnum Field2 = 2 [(gogoproto.customname) = "FieldB"]; +} + +message NoExtensionsMap { + option (gogoproto.face) = false; + option (gogoproto.goproto_extensions_map) = false; + optional int64 Field1 = 1; + extensions 100 to 199; +} + +extend NoExtensionsMap { + optional double FieldA1 = 100; + optional NinOptNative FieldB1 = 101; + optional NinEmbeddedStruct FieldC1 = 102; +} + +message Unrecognized { + option (gogoproto.goproto_unrecognized) = false; + optional string Field1 = 1; +} + +message UnrecognizedWithInner { + message Inner { + option (gogoproto.goproto_unrecognized) = false; + optional uint32 Field1 = 1; + } + + repeated Inner embedded = 1; + optional string Field2 = 2; +} + +message UnrecognizedWithEmbed { + message Embedded { + option (gogoproto.goproto_unrecognized) = false; + optional uint32 Field1 = 1; + } + + optional Embedded embedded = 1 [(gogoproto.embed) = true, (gogoproto.nullable) = false]; + optional string Field2 = 2; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/marshaler/thetestpb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/marshaler/thetestpb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..d3a7bb5b399b02c7ba523f478fa69e17219841ef --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/marshaler/thetestpb_test.go @@ -0,0 +1,14647 @@ +// Code generated by protoc-gen-gogo. +// source: combos/marshaler/thetest.proto +// DO NOT EDIT! + +/* +Package test is a generated protocol buffer package. + +It is generated from these files: + combos/marshaler/thetest.proto + +It has these top-level messages: + NidOptNative + NinOptNative + NidRepNative + NinRepNative + NidRepPackedNative + NinRepPackedNative + NidOptStruct + NinOptStruct + NidRepStruct + NinRepStruct + NidEmbeddedStruct + NinEmbeddedStruct + NidNestedStruct + NinNestedStruct + NidOptCustom + CustomDash + NinOptCustom + NidRepCustom + NinRepCustom + NinOptNativeUnion + NinOptStructUnion + NinEmbeddedStructUnion + NinNestedStructUnion + Tree + OrBranch + AndBranch + Leaf + DeepTree + ADeepBranch + AndDeepBranch + DeepLeaf + Nil + NidOptEnum + NinOptEnum + NidRepEnum + NinRepEnum + NinOptEnumDefault + AnotherNinOptEnum + AnotherNinOptEnumDefault + Timer + MyExtendable + OtherExtenable + NestedDefinition + NestedScope + NinOptNativeDefault + CustomContainer + CustomNameNidOptNative + CustomNameNinOptNative + CustomNameNinRepNative + CustomNameNinStruct + CustomNameCustomType + CustomNameNinEmbeddedStructUnion + CustomNameEnum + NoExtensionsMap + Unrecognized + UnrecognizedWithInner + UnrecognizedWithEmbed +*/ +package test + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestNidOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidOptNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepPackedNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepPackedNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepPackedNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepPackedNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepPackedNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepPackedNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepPackedNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepPackedNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepPackedNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepPackedNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepPackedNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepPackedNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepPackedNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepPackedNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidOptStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidOptStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidEmbeddedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidEmbeddedStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidEmbeddedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidEmbeddedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidEmbeddedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidEmbeddedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidEmbeddedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinEmbeddedStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinEmbeddedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinEmbeddedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinEmbeddedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidNestedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidNestedStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidNestedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidNestedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidNestedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidNestedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidNestedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinNestedStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinNestedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinNestedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinNestedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidOptCustomMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidOptCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomDashProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomDashMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomDashProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomDash, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomDash(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomDashProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomDash(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomDash{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptCustomMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepCustomMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepCustomMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptNativeUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptNativeUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNativeUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNativeUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptStructUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinEmbeddedStructUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinEmbeddedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinEmbeddedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinNestedStructUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinNestedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinNestedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinNestedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinNestedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestTreeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestTreeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkTreeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Tree, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkTreeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTree(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Tree{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestOrBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestOrBranchMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkOrBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OrBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedOrBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkOrBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOrBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &OrBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAndBranchMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAndBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAndBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAndBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AndBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestLeafProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestLeafMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkLeafProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Leaf, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkLeafProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLeaf(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Leaf{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepTreeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestDeepTreeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkDeepTreeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepTree, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedDeepTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkDeepTreeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepTree(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &DeepTree{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestADeepBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestADeepBranchMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkADeepBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*ADeepBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedADeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkADeepBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedADeepBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &ADeepBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndDeepBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAndDeepBranchMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAndDeepBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndDeepBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAndDeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAndDeepBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndDeepBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AndDeepBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepLeafProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestDeepLeafMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkDeepLeafProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepLeaf, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedDeepLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkDeepLeafProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepLeaf(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &DeepLeaf{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNilProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNilMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNilProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nil, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNil(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNilProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNil(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Nil{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidOptEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptEnumDefaultMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptEnumDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnumDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptEnumDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnumDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptEnumDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAnotherNinOptEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAnotherNinOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAnotherNinOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AnotherNinOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAnotherNinOptEnumDefaultMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAnotherNinOptEnumDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnumDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAnotherNinOptEnumDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnumDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AnotherNinOptEnumDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestTimerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestTimerMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkTimerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Timer, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedTimer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkTimerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTimer(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Timer{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMyExtendableProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestMyExtendableMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkMyExtendableProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MyExtendable, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMyExtendable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMyExtendableProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMyExtendable(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &MyExtendable{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestOtherExtenableProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestOtherExtenableMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkOtherExtenableProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OtherExtenable, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedOtherExtenable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkOtherExtenableProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOtherExtenable(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &OtherExtenable{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinitionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedDefinitionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedDefinitionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinitionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessageProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedDefinition_NestedMessageMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedDefinition_NestedMessageProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinition_NestedMessageProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition_NestedMessage{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedScopeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedScopeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedScopeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedScope, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedScope(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedScopeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedScope(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedScope{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptNativeDefaultMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptNativeDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNativeDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNativeDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomContainerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomContainerMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomContainerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomContainer, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomContainer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomContainerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomContainer(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomContainer{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNidOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNidOptNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNidOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNidOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNidOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNidOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNidOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNinOptNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNinOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNinRepNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNinRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNinStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNinStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameCustomTypeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameCustomTypeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameCustomTypeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameCustomType, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameCustomType(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameCustomTypeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameCustomType(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameCustomType{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinEmbeddedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNinEmbeddedStructUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNinEmbeddedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinEmbeddedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinEmbeddedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNoExtensionsMapProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNoExtensionsMapMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNoExtensionsMapProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NoExtensionsMap, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNoExtensionsMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNoExtensionsMapProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNoExtensionsMap(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NoExtensionsMap{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Unrecognized, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognized(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognized(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Unrecognized{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInnerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedWithInnerMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedWithInnerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithInnerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithInner{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInner_InnerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedWithInner_InnerMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedWithInner_InnerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner_Inner, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithInner_InnerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner_Inner(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithInner_Inner{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedWithEmbedMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedWithEmbedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithEmbedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithEmbed{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbed_EmbeddedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed_Embedded, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithEmbed_Embedded{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepPackedNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepPackedNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidEmbeddedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinEmbeddedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidNestedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinNestedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomDashJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinEmbeddedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinNestedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTreeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOrBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAndBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestLeafJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestDeepTreeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestADeepBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAndDeepBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestDeepLeafJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNilJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptEnumDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAnotherNinOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAnotherNinOptEnumDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTimerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMyExtendableJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOtherExtenableJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinitionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinition_NestedMessageJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedScopeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomContainerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNidOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameCustomTypeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNoExtensionsMapJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithInnerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithInner_InnerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithEmbedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithEmbed_EmbeddedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepPackedNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepPackedNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepPackedNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepPackedNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidEmbeddedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidEmbeddedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidNestedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidNestedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomDashProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomDashProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTreeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTreeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOrBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOrBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestLeafProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestLeafProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepTreeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepTreeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestADeepBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestADeepBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndDeepBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndDeepBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepLeafProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepLeafProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNilProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNilProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTimerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTimerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMyExtendableProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMyExtendableProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOtherExtenableProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOtherExtenableProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinitionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinitionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessageProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessageProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedScopeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedScopeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomContainerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomContainerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNidOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNidOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameCustomTypeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameCustomTypeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinEmbeddedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinEmbeddedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNoExtensionsMapProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNoExtensionsMapProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInnerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInnerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInner_InnerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInner_InnerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestThetestDescription(t *testing.T) { + ThetestDescription() +} +func TestNidOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepPackedNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepPackedNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidEmbeddedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinEmbeddedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidNestedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinNestedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomDashVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinNestedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTreeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOrBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAndBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestLeafVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestDeepTreeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestADeepBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAndDeepBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestDeepLeafVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNilVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptEnumDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAnotherNinOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAnotherNinOptEnumDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTimerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMyExtendableVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOtherExtenableVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinitionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinition_NestedMessageVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedScopeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomContainerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNidOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameCustomTypeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNoExtensionsMapVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithInnerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithInner_InnerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithEmbedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithEmbed_EmbeddedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepPackedNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepPackedNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidEmbeddedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidNestedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinNestedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomDashFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptNativeUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinNestedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestTreeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestOrBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAndBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestLeafFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestDeepTreeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestADeepBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAndDeepBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestDeepLeafFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNilFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAnotherNinOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestTimerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinitionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinition_NestedMessageFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedScopeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomContainerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNidOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameCustomTypeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithInnerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithInner_InnerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithEmbedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithEmbed_EmbeddedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepPackedNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepPackedNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidEmbeddedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinEmbeddedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidNestedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinNestedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomDashGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinEmbeddedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinNestedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTreeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOrBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAndBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestLeafGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestDeepTreeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestADeepBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAndDeepBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestDeepLeafGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNilGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptEnumDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAnotherNinOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAnotherNinOptEnumDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTimerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMyExtendableGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOtherExtenableGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinitionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinition_NestedMessageGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedScopeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomContainerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNidOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameCustomTypeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinEmbeddedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNoExtensionsMapGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithInnerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithInner_InnerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithEmbedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithEmbed_EmbeddedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepPackedNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepPackedNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepPackedNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepPackedNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepPackedNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepPackedNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidEmbeddedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidEmbeddedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidEmbeddedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinEmbeddedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidNestedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidNestedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidNestedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinNestedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomDashSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomDashSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomDash, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomDash(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNativeUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinEmbeddedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinNestedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinNestedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestTreeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkTreeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Tree, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestOrBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkOrBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OrBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedOrBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAndBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAndBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestLeafSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkLeafSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Leaf, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepTreeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkDeepTreeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepTree, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedDeepTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestADeepBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkADeepBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*ADeepBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedADeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndDeepBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAndDeepBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndDeepBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAndDeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepLeafSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkDeepLeafSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepLeaf, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedDeepLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNilSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNilSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nil, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNil(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptEnumDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnumDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAnotherNinOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAnotherNinOptEnumDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnumDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestTimerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkTimerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Timer, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedTimer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMyExtendableSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMyExtendableSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MyExtendable, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMyExtendable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestOtherExtenableSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkOtherExtenableSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OtherExtenable, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedOtherExtenable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinitionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinitionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessageSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinition_NestedMessageSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedScopeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedScopeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedScope, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedScope(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNativeDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomContainerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomContainerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomContainer, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomContainer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNidOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNidOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNidOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameCustomTypeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameCustomTypeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameCustomType, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameCustomType(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinEmbeddedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinEmbeddedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinEmbeddedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNoExtensionsMapSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNoExtensionsMapSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NoExtensionsMap, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNoExtensionsMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Unrecognized, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognized(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInnerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithInnerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInner_InnerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithInner_InnerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner_Inner, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithEmbedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbed_EmbeddedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed_Embedded, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepPackedNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepPackedNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidEmbeddedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinEmbeddedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidNestedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinNestedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomDashStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinEmbeddedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinNestedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTreeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOrBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAndBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestLeafStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestDeepTreeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestADeepBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAndDeepBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestDeepLeafStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNilStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptEnumDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAnotherNinOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAnotherNinOptEnumDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTimerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestMyExtendableStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOtherExtenableStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinitionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinition_NestedMessageStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedScopeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomContainerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNidOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameCustomTypeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinEmbeddedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNoExtensionsMapStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithInnerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithInner_InnerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithEmbedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithEmbed_EmbeddedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, true) + v := p.GetValue() + msg := &NinOptNativeUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinOptStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, true) + v := p.GetValue() + msg := &NinOptStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + v := p.GetValue() + msg := &NinEmbeddedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinNestedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, true) + v := p.GetValue() + msg := &NinNestedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestTreeOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, true) + v := p.GetValue() + msg := &Tree{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestDeepTreeOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, true) + v := p.GetValue() + msg := &DeepTree{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + v := p.GetValue() + msg := &CustomNameNinEmbeddedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/marshaler/uuid.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/marshaler/uuid.go new file mode 100644 index 0000000000000000000000000000000000000000..4c071114bcce237893cd1f0fa4baca9d8663b571 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/marshaler/uuid.go @@ -0,0 +1,122 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 test + +import ( + "bytes" + "encoding/json" +) + +func PutLittleEndianUint64(b []byte, offset int, v uint64) { + b[offset] = byte(v) + b[offset+1] = byte(v >> 8) + b[offset+2] = byte(v >> 16) + b[offset+3] = byte(v >> 24) + b[offset+4] = byte(v >> 32) + b[offset+5] = byte(v >> 40) + b[offset+6] = byte(v >> 48) + b[offset+7] = byte(v >> 56) +} + +type Uuid []byte + +func (uuid Uuid) Marshal() ([]byte, error) { + if len(uuid) == 0 { + return nil, nil + } + return []byte(uuid), nil +} + +func (uuid Uuid) MarshalTo(data []byte) (n int, err error) { + if len(uuid) == 0 { + return 0, nil + } + copy(data, uuid) + return 16, nil +} + +func (uuid *Uuid) Unmarshal(data []byte) error { + if len(data) == 0 { + uuid = nil + return nil + } + id := Uuid(make([]byte, 16)) + copy(id, data) + *uuid = id + return nil +} + +func (uuid *Uuid) Size() int { + if uuid == nil { + return 0 + } + if len(*uuid) == 0 { + return 0 + } + return 16 +} + +func (uuid Uuid) MarshalJSON() ([]byte, error) { + return json.Marshal([]byte(uuid)) +} + +func (uuid *Uuid) UnmarshalJSON(data []byte) error { + v := new([]byte) + err := json.Unmarshal(data, v) + if err != nil { + return err + } + return uuid.Unmarshal(*v) +} + +func (uuid Uuid) Equal(other Uuid) bool { + return bytes.Equal(uuid[0:], other[0:]) +} + +type int63 interface { + Int63() int64 +} + +func NewPopulatedUuid(r int63) *Uuid { + u := RandV4(r) + return &u +} + +func RandV4(r int63) Uuid { + uuid := make(Uuid, 16) + uuid.RandV4(r) + return uuid +} + +func (uuid Uuid) RandV4(r int63) { + PutLittleEndianUint64(uuid, 0, uint64(r.Int63())) + PutLittleEndianUint64(uuid, 8, uint64(r.Int63())) + uuid[6] = (uuid[6] & 0xf) | 0x40 + uuid[8] = (uuid[8] & 0x3f) | 0x80 +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unmarshaler/bug_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unmarshaler/bug_test.go new file mode 100644 index 0000000000000000000000000000000000000000..264d3982327d7276cc42c9314074f391dde60dfa --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unmarshaler/bug_test.go @@ -0,0 +1,186 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 test + +import ( + "fmt" + "math" + "testing" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +) + +//http://code.google.com/p/goprotobuf/issues/detail?id=39 +func TestBugUint32VarintSize(t *testing.T) { + temp := uint32(math.MaxUint32) + n := &NinOptNative{} + n.Field5 = &temp + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != 6 { + t.Fatalf("data should be length 6, but its %#v", data) + } +} + +func TestBugZeroLengthSliceSize(t *testing.T) { + n := &NinRepPackedNative{ + Field8: []int64{}, + } + size := n.Size() + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != size { + t.Fatalf("expected %v, but got %v", len(data), size) + } +} + +//http://code.google.com/p/goprotobuf/issues/detail?id=40 +func TestBugPackedProtoSize(t *testing.T) { + n := &NinRepPackedNative{ + Field4: []int64{172960727389894724, 2360337516664475010, 860833876131988189, 9068073014890763245, 7794843386260381831, 4023536436053141786, 8992311247496919020, 4330096163611305776, 4490411416244976467, 7873947349172707443, 2754969595834279669, 1360667855926938684, 4771480785172657389, 4875578924966668055, 8070579869808877481, 9128179594766551001, 4630419407064527516, 863844540220372892, 8208727650143073487, 7086117356301045838, 7779695211931506151, 5493835345187563535, 9119767633370806007, 9054342025895349248, 1887303228838508438, 7624573031734528281, 1874668389749611225, 3517684643468970593, 6677697606628877758, 7293473953189936168, 444475066704085538, 8594971141363049302, 1146643249094989673, 733393306232853371, 7721178528893916886, 7784452000911004429, 6436373110242711440, 6897422461738321237, 8772249155667732778, 6211871464311393541, 3061903718310406883, 7845488913176136641, 8342255034663902574, 3443058984649725748, 8410801047334832902, 7496541071517841153, 4305416923521577765, 7814967600020476457, 8671843803465481186, 3490266370361096855, 1447425664719091336, 653218597262334239, 8306243902880091940, 7851896059762409081, 5936760560798954978, 5755724498441478025, 7022701569985035966, 3707709584811468220, 529069456924666920, 7986469043681522462, 3092513330689518836, 5103541550470476202, 3577384161242626406, 3733428084624703294, 8388690542440473117, 3262468785346149388, 8788358556558007570, 5476276940198542020, 7277903243119461239, 5065861426928605020, 7533460976202697734, 1749213838654236956, 557497603941617931, 5496307611456481108, 6444547750062831720, 6992758776744205596, 7356719693428537399, 2896328872476734507, 381447079530132038, 598300737753233118, 3687980626612697715, 7240924191084283349, 8172414415307971170, 4847024388701257185, 2081764168600256551, 3394217778539123488, 6244660626429310923, 8301712215675381614, 5360615125359461174, 8410140945829785773, 3152963269026381373, 6197275282781459633, 4419829061407546410, 6262035523070047537, 2837207483933463885, 2158105736666826128, 8150764172235490711}, + Field7: []int32{249451845, 1409974015, 393609128, 435232428, 1817529040, 91769006, 861170933, 1556185603, 1568580279, 1236375273, 512276621, 693633711, 967580535, 1950715977, 853431462, 1362390253, 159591204, 111900629, 322985263, 279671129, 1592548430, 465651370, 733849989, 1172059400, 1574824441, 263541092, 1271612397, 1520584358, 467078791, 117698716, 1098255064, 2054264846, 1766452305, 1267576395, 1557505617, 1187833560, 956187431, 1970977586, 1160235159, 1610259028, 489585797, 459139078, 566263183, 954319278, 1545018565, 1753946743, 948214318, 422878159, 883926576, 1424009347, 824732372, 1290433180, 80297942, 417294230, 1402647904, 2078392782, 220505045, 787368129, 463781454, 293083578, 808156928, 293976361}, + Field9: []uint32{0xaa4976e8, 0x3da8cc4c, 0x8c470d83, 0x344d964e, 0x5b90925, 0xa4c4d34e, 0x666eff19, 0xc238e552, 0x9be53bb6, 0x56364245, 0x33ee079d, 0x96bf0ede, 0x7941b74f, 0xdb07cb47, 0x6d76d827, 0x9b211d5d, 0x2798adb6, 0xe48b0c3b, 0x87061b21, 0x48f4e4d2, 0x3e5d5c12, 0x5ee91288, 0x336d4f35, 0xe1d44941, 0xc065548d, 0x2953d73f, 0x873af451, 0xfc769db, 0x9f1bf8da, 0x9baafdfc, 0xf1d3d770, 0x5bb5d2b4, 0xc2c67c48, 0x6845c4c1, 0xa48f32b0, 0xbb04bb70, 0xa5b1ca36, 0x8d98356a, 0x2171f654, 0x5ae279b0, 0x6c4a3d6b, 0x4fff5468, 0xcf9bf851, 0x68513614, 0xdbecd9b0, 0x9553ed3c, 0xa494a736, 0x42205438, 0xbf8e5caa, 0xd3283c6, 0x76d20788, 0x9179826f, 0x96b24f85, 0xbc2eacf4, 0xe4afae0b, 0x4bca85cb, 0x35e63b5b, 0xd7ccee0c, 0x2b506bb9, 0xe78e9f44, 0x9ad232f1, 0x99a37335, 0xa5d6ffc8}, + Field11: []uint64{0x53c01ebc, 0x4fb85ba6, 0x8805eea1, 0xb20ec896, 0x93b63410, 0xec7c9492, 0x50765a28, 0x19592106, 0x2ecc59b3, 0x39cd474f, 0xe4c9e47, 0x444f48c5, 0xe7731d32, 0xf3f43975, 0x603caedd, 0xbb05a1af, 0xa808e34e, 0x88580b07, 0x4c96bbd1, 0x730b4ab9, 0xed126e2b, 0x6db48205, 0x154ba1b9, 0xc26bfb6a, 0x389aa052, 0x869d966c, 0x7c86b366, 0xcc8edbcd, 0xfa8d6dad, 0xcf5857d9, 0x2d9cda0f, 0x1218a0b8, 0x41bf997, 0xf0ca65ac, 0xa610d4b9, 0x8d362e28, 0xb7212d87, 0x8e0fe109, 0xbee041d9, 0x759be2f6, 0x35fef4f3, 0xaeacdb71, 0x10888852, 0xf4e28117, 0xe2a14812, 0x73b748dc, 0xd1c3c6b2, 0xfef41bf0, 0xc9b43b62, 0x810e4faa, 0xcaa41c06, 0x1893fe0d, 0xedc7c850, 0xd12b9eaa, 0x467ee1a9, 0xbe84756b, 0xda7b1680, 0xdc069ffe, 0xf1e7e9f9, 0xb3d95370, 0xa92b77df, 0x5693ac41, 0xd04b7287, 0x27aebf15, 0x837b316e, 0x4dbe2263, 0xbab70c67, 0x547dab21, 0x3c346c1f, 0xb8ef0e4e, 0xfe2d03ce, 0xe1d75955, 0xfec1306, 0xba35c23e, 0xb784ed04, 0x2a4e33aa, 0x7e19d09a, 0x3827c1fe, 0xf3a51561, 0xef765e2b, 0xb044256c, 0x62b322be, 0xf34d56be, 0xeb71b369, 0xffe1294f, 0x237fe8d0, 0x77a1473b, 0x239e1196, 0xdd19bf3d, 0x82c91fe1, 0x95361c57, 0xffea3f1b, 0x1a094c84}, + Field12: []int64{8308420747267165049, 3664160795077875961, 7868970059161834817, 7237335984251173739, 5254748003907196506, 3362259627111837480, 430460752854552122, 5119635556501066533, 1277716037866233522, 9185775384759813768, 833932430882717888, 7986528304451297640, 6792233378368656337, 2074207091120609721, 1788723326198279432, 7756514594746453657, 2283775964901597324, 3061497730110517191, 7733947890656120277, 626967303632386244, 7822928600388582821, 3489658753000061230, 168869995163005961, 248814782163480763, 477885608911386247, 4198422415674133867, 3379354662797976109, 9925112544736939, 1486335136459138480, 4561560414032850671, 1010864164014091267, 186722821683803084, 5106357936724819318, 1298160820191228988, 4675403242419953145, 7130634540106489752, 7101280006672440929, 7176058292431955718, 9109875054097770321, 6810974877085322872, 4736707874303993641, 8993135362721382187, 6857881554990254283, 3704748883307461680, 1099360832887634994, 5207691918707192633, 5984721695043995243}, + } + size := proto.Size(n) + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != size { + t.Fatalf("expected %v, but got %v diff is %v", len(data), size, len(data)-size) + } +} + +func testSize(m interface { + proto.Message + Size() int +}, desc string, expected int) ([]byte, error) { + data, err := proto.Marshal(m) + if err != nil { + return nil, err + } + protoSize := proto.Size(m) + mSize := m.Size() + lenData := len(data) + if protoSize != mSize || protoSize != lenData || mSize != lenData { + return nil, fmt.Errorf("%s proto.Size(m){%d} != m.Size(){%d} != len(data){%d}", desc, protoSize, mSize, lenData) + } + if got := protoSize; got != expected { + return nil, fmt.Errorf("%s proto.Size(m) got %d expected %d", desc, got, expected) + } + if got := mSize; got != expected { + return nil, fmt.Errorf("%s m.Size() got %d expected %d", desc, got, expected) + } + if got := lenData; got != expected { + return nil, fmt.Errorf("%s len(data) got %d expected %d", desc, got, expected) + } + return data, nil +} + +func TestInt32Int64Compatibility(t *testing.T) { + + //test nullable int32 and int64 + + data1, err := testSize(&NinOptNative{ + Field3: proto.Int32(-1), + }, "nullable", 11) + if err != nil { + t.Error(err) + } + //change marshaled data1 to unmarshal into 4th field which is an int64 + data1[0] = uint8(uint32(4 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + u1 := &NinOptNative{} + if err := proto.Unmarshal(data1, u1); err != nil { + t.Error(err) + } + if !u1.Equal(&NinOptNative{ + Field4: proto.Int64(-1), + }) { + t.Error("nullable unmarshaled int32 is not the same int64") + } + + //test non-nullable int32 and int64 + + data2, err := testSize(&NidOptNative{ + Field3: -1, + }, "non nullable", 67) + if err != nil { + t.Error(err) + } + //change marshaled data2 to unmarshal into 4th field which is an int64 + field3 := uint8(uint32(3 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + field4 := uint8(uint32(4 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + for i, c := range data2 { + if c == field4 { + data2[i] = field3 + } else if c == field3 { + data2[i] = field4 + } + } + u2 := &NidOptNative{} + if err := proto.Unmarshal(data2, u2); err != nil { + t.Error(err) + } + if !u2.Equal(&NidOptNative{ + Field4: -1, + }) { + t.Error("non nullable unmarshaled int32 is not the same int64") + } + + //test packed repeated int32 and int64 + + m4 := &NinRepPackedNative{ + Field3: []int32{-1}, + } + data4, err := testSize(m4, "packed", 12) + if err != nil { + t.Error(err) + } + u4 := &NinRepPackedNative{} + if err := proto.Unmarshal(data4, u4); err != nil { + t.Error(err) + } + if err := u4.VerboseEqual(m4); err != nil { + t.Fatalf("%#v", u4) + } + + //test repeated int32 and int64 + + if _, err := testSize(&NinRepNative{ + Field3: []int32{-1}, + }, "repeated", 11); err != nil { + t.Error(err) + } + + t.Logf("tested all") +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unmarshaler/thetest.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unmarshaler/thetest.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..b16811dff2f044e8536d4c6724f588407c1047a0 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unmarshaler/thetest.pb.go @@ -0,0 +1,33056 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unmarshaler/thetest.proto +// DO NOT EDIT! + +/* + Package test is a generated protocol buffer package. + + It is generated from these files: + combos/unmarshaler/thetest.proto + + It has these top-level messages: + NidOptNative + NinOptNative + NidRepNative + NinRepNative + NidRepPackedNative + NinRepPackedNative + NidOptStruct + NinOptStruct + NidRepStruct + NinRepStruct + NidEmbeddedStruct + NinEmbeddedStruct + NidNestedStruct + NinNestedStruct + NidOptCustom + CustomDash + NinOptCustom + NidRepCustom + NinRepCustom + NinOptNativeUnion + NinOptStructUnion + NinEmbeddedStructUnion + NinNestedStructUnion + Tree + OrBranch + AndBranch + Leaf + DeepTree + ADeepBranch + AndDeepBranch + DeepLeaf + Nil + NidOptEnum + NinOptEnum + NidRepEnum + NinRepEnum + NinOptEnumDefault + AnotherNinOptEnum + AnotherNinOptEnumDefault + Timer + MyExtendable + OtherExtenable + NestedDefinition + NestedScope + NinOptNativeDefault + CustomContainer + CustomNameNidOptNative + CustomNameNinOptNative + CustomNameNinRepNative + CustomNameNinStruct + CustomNameCustomType + CustomNameNinEmbeddedStructUnion + CustomNameEnum + NoExtensionsMap + Unrecognized + UnrecognizedWithInner + UnrecognizedWithEmbed +*/ +package test + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_custom "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom" +import github_com_gogo_protobuf_test_custom_dash_type "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom-dash-type" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type TheTestEnum int32 + +const ( + A TheTestEnum = 0 + B TheTestEnum = 1 + C TheTestEnum = 2 +) + +var TheTestEnum_name = map[int32]string{ + 0: "A", + 1: "B", + 2: "C", +} +var TheTestEnum_value = map[string]int32{ + "A": 0, + "B": 1, + "C": 2, +} + +func (x TheTestEnum) Enum() *TheTestEnum { + p := new(TheTestEnum) + *p = x + return p +} +func (x TheTestEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(TheTestEnum_name, int32(x)) +} +func (x *TheTestEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(TheTestEnum_value, data, "TheTestEnum") + if err != nil { + return err + } + *x = TheTestEnum(value) + return nil +} + +type AnotherTestEnum int32 + +const ( + D AnotherTestEnum = 10 + E AnotherTestEnum = 11 +) + +var AnotherTestEnum_name = map[int32]string{ + 10: "D", + 11: "E", +} +var AnotherTestEnum_value = map[string]int32{ + "D": 10, + "E": 11, +} + +func (x AnotherTestEnum) Enum() *AnotherTestEnum { + p := new(AnotherTestEnum) + *p = x + return p +} +func (x AnotherTestEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(AnotherTestEnum_name, int32(x)) +} +func (x *AnotherTestEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(AnotherTestEnum_value, data, "AnotherTestEnum") + if err != nil { + return err + } + *x = AnotherTestEnum(value) + return nil +} + +type NestedDefinition_NestedEnum int32 + +const ( + TYPE_NESTED NestedDefinition_NestedEnum = 1 +) + +var NestedDefinition_NestedEnum_name = map[int32]string{ + 1: "TYPE_NESTED", +} +var NestedDefinition_NestedEnum_value = map[string]int32{ + "TYPE_NESTED": 1, +} + +func (x NestedDefinition_NestedEnum) Enum() *NestedDefinition_NestedEnum { + p := new(NestedDefinition_NestedEnum) + *p = x + return p +} +func (x NestedDefinition_NestedEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(NestedDefinition_NestedEnum_name, int32(x)) +} +func (x *NestedDefinition_NestedEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(NestedDefinition_NestedEnum_value, data, "NestedDefinition_NestedEnum") + if err != nil { + return err + } + *x = NestedDefinition_NestedEnum(value) + return nil +} + +type NidOptNative struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + Field3 int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3"` + Field4 int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4"` + Field5 uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5"` + Field6 uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8"` + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9"` + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10"` + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11"` + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12"` + Field13 bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + Field14 string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptNative) Reset() { *m = NidOptNative{} } +func (*NidOptNative) ProtoMessage() {} + +type NinOptNative struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"` + Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"` + Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"` + Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"` + Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNative) Reset() { *m = NinOptNative{} } +func (*NinOptNative) ProtoMessage() {} + +type NidRepNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepNative) Reset() { *m = NidRepNative{} } +func (*NidRepNative) ProtoMessage() {} + +type NinRepNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepNative) Reset() { *m = NinRepNative{} } +func (*NinRepNative) ProtoMessage() {} + +type NidRepPackedNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepPackedNative) Reset() { *m = NidRepPackedNative{} } +func (*NidRepPackedNative) ProtoMessage() {} + +type NinRepPackedNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepPackedNative) Reset() { *m = NinRepPackedNative{} } +func (*NinRepPackedNative) ProtoMessage() {} + +type NidOptStruct struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + Field3 NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3"` + Field4 NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4"` + Field6 uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + Field8 NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8"` + Field13 bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + Field14 string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptStruct) Reset() { *m = NidOptStruct{} } +func (*NidOptStruct) ProtoMessage() {} + +type NinOptStruct struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field8 *NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptStruct) Reset() { *m = NinOptStruct{} } +func (*NinOptStruct) ProtoMessage() {} + +type NidRepStruct struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []NidOptNative `protobuf:"bytes,3,rep,name=Field3" json:"Field3"` + Field4 []NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []NidOptNative `protobuf:"bytes,8,rep,name=Field8" json:"Field8"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepStruct) Reset() { *m = NidRepStruct{} } +func (*NidRepStruct) ProtoMessage() {} + +type NinRepStruct struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []*NidOptNative `protobuf:"bytes,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []*NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []*NidOptNative `protobuf:"bytes,8,rep,name=Field8" json:"Field8,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepStruct) Reset() { *m = NinRepStruct{} } +func (*NinRepStruct) ProtoMessage() {} + +type NidEmbeddedStruct struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 NidOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200"` + Field210 bool `protobuf:"varint,210,opt,name=Field210" json:"Field210"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidEmbeddedStruct) Reset() { *m = NidEmbeddedStruct{} } +func (*NidEmbeddedStruct) ProtoMessage() {} + +type NinEmbeddedStruct struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 *NidOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + Field210 *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinEmbeddedStruct) Reset() { *m = NinEmbeddedStruct{} } +func (*NinEmbeddedStruct) ProtoMessage() {} + +type NidNestedStruct struct { + Field1 NidOptStruct `protobuf:"bytes,1,opt,name=Field1" json:"Field1"` + Field2 []NidRepStruct `protobuf:"bytes,2,rep,name=Field2" json:"Field2"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidNestedStruct) Reset() { *m = NidNestedStruct{} } +func (*NidNestedStruct) ProtoMessage() {} + +type NinNestedStruct struct { + Field1 *NinOptStruct `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 []*NinRepStruct `protobuf:"bytes,2,rep,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinNestedStruct) Reset() { *m = NinNestedStruct{} } +func (*NinNestedStruct) ProtoMessage() {} + +type NidOptCustom struct { + Id Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id"` + Value github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptCustom) Reset() { *m = NidOptCustom{} } +func (*NidOptCustom) ProtoMessage() {} + +type CustomDash struct { + Value *github_com_gogo_protobuf_test_custom_dash_type.Bytes `protobuf:"bytes,1,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom-dash-type.Bytes" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomDash) Reset() { *m = CustomDash{} } +func (*CustomDash) ProtoMessage() {} + +type NinOptCustom struct { + Id *Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id,omitempty"` + Value *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptCustom) Reset() { *m = NinOptCustom{} } +func (*NinOptCustom) ProtoMessage() {} + +type NidRepCustom struct { + Id []Uuid `protobuf:"bytes,1,rep,name=Id,customtype=Uuid" json:"Id"` + Value []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepCustom) Reset() { *m = NidRepCustom{} } +func (*NidRepCustom) ProtoMessage() {} + +type NinRepCustom struct { + Id []Uuid `protobuf:"bytes,1,rep,name=Id,customtype=Uuid" json:"Id,omitempty"` + Value []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepCustom) Reset() { *m = NinRepCustom{} } +func (*NinRepCustom) ProtoMessage() {} + +type NinOptNativeUnion struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNativeUnion) Reset() { *m = NinOptNativeUnion{} } +func (*NinOptNativeUnion) ProtoMessage() {} + +type NinOptStructUnion struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptStructUnion) Reset() { *m = NinOptStructUnion{} } +func (*NinOptStructUnion) ProtoMessage() {} + +type NinEmbeddedStructUnion struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 *NinOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + Field210 *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinEmbeddedStructUnion) Reset() { *m = NinEmbeddedStructUnion{} } +func (*NinEmbeddedStructUnion) ProtoMessage() {} + +type NinNestedStructUnion struct { + Field1 *NinOptNativeUnion `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *NinOptStructUnion `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NinEmbeddedStructUnion `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinNestedStructUnion) Reset() { *m = NinNestedStructUnion{} } +func (*NinNestedStructUnion) ProtoMessage() {} + +type Tree struct { + Or *OrBranch `protobuf:"bytes,1,opt,name=Or" json:"Or,omitempty"` + And *AndBranch `protobuf:"bytes,2,opt,name=And" json:"And,omitempty"` + Leaf *Leaf `protobuf:"bytes,3,opt,name=Leaf" json:"Leaf,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Tree) Reset() { *m = Tree{} } +func (*Tree) ProtoMessage() {} + +type OrBranch struct { + Left Tree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right Tree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OrBranch) Reset() { *m = OrBranch{} } +func (*OrBranch) ProtoMessage() {} + +type AndBranch struct { + Left Tree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right Tree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AndBranch) Reset() { *m = AndBranch{} } +func (*AndBranch) ProtoMessage() {} + +type Leaf struct { + Value int64 `protobuf:"varint,1,opt,name=Value" json:"Value"` + StrValue string `protobuf:"bytes,2,opt,name=StrValue" json:"StrValue"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Leaf) Reset() { *m = Leaf{} } +func (*Leaf) ProtoMessage() {} + +type DeepTree struct { + Down *ADeepBranch `protobuf:"bytes,1,opt,name=Down" json:"Down,omitempty"` + And *AndDeepBranch `protobuf:"bytes,2,opt,name=And" json:"And,omitempty"` + Leaf *DeepLeaf `protobuf:"bytes,3,opt,name=Leaf" json:"Leaf,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeepTree) Reset() { *m = DeepTree{} } +func (*DeepTree) ProtoMessage() {} + +type ADeepBranch struct { + Down DeepTree `protobuf:"bytes,2,opt,name=Down" json:"Down"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ADeepBranch) Reset() { *m = ADeepBranch{} } +func (*ADeepBranch) ProtoMessage() {} + +type AndDeepBranch struct { + Left DeepTree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right DeepTree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AndDeepBranch) Reset() { *m = AndDeepBranch{} } +func (*AndDeepBranch) ProtoMessage() {} + +type DeepLeaf struct { + Tree Tree `protobuf:"bytes,1,opt,name=Tree" json:"Tree"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeepLeaf) Reset() { *m = DeepLeaf{} } +func (*DeepLeaf) ProtoMessage() {} + +type Nil struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *Nil) Reset() { *m = Nil{} } +func (*Nil) ProtoMessage() {} + +type NidOptEnum struct { + Field1 TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptEnum) Reset() { *m = NidOptEnum{} } +func (*NidOptEnum) ProtoMessage() {} + +type NinOptEnum struct { + Field1 *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptEnum) Reset() { *m = NinOptEnum{} } +func (*NinOptEnum) ProtoMessage() {} + +type NidRepEnum struct { + Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepEnum) Reset() { *m = NidRepEnum{} } +func (*NidRepEnum) ProtoMessage() {} + +type NinRepEnum struct { + Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepEnum) Reset() { *m = NinRepEnum{} } +func (*NinRepEnum) ProtoMessage() {} + +type NinOptEnumDefault struct { + Field1 *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum,def=2" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptEnumDefault) Reset() { *m = NinOptEnumDefault{} } +func (*NinOptEnumDefault) ProtoMessage() {} + +const Default_NinOptEnumDefault_Field1 TheTestEnum = C + +func (m *NinOptEnumDefault) GetField1() TheTestEnum { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_NinOptEnumDefault_Field1 +} + +type AnotherNinOptEnum struct { + Field1 *AnotherTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.AnotherTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AnotherNinOptEnum) Reset() { *m = AnotherNinOptEnum{} } +func (*AnotherNinOptEnum) ProtoMessage() {} + +type AnotherNinOptEnumDefault struct { + Field1 *AnotherTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.AnotherTestEnum,def=11" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AnotherNinOptEnumDefault) Reset() { *m = AnotherNinOptEnumDefault{} } +func (*AnotherNinOptEnumDefault) ProtoMessage() {} + +const Default_AnotherNinOptEnumDefault_Field1 AnotherTestEnum = E + +func (m *AnotherNinOptEnumDefault) GetField1() AnotherTestEnum { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_AnotherNinOptEnumDefault_Field1 +} + +type Timer struct { + Time1 int64 `protobuf:"fixed64,1,opt,name=Time1" json:"Time1"` + Time2 int64 `protobuf:"fixed64,2,opt,name=Time2" json:"Time2"` + Data []byte `protobuf:"bytes,3,opt,name=Data" json:"Data"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Timer) Reset() { *m = Timer{} } +func (*Timer) ProtoMessage() {} + +type MyExtendable struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MyExtendable) Reset() { *m = MyExtendable{} } +func (*MyExtendable) ProtoMessage() {} + +var extRange_MyExtendable = []proto.ExtensionRange{ + {100, 199}, +} + +func (*MyExtendable) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MyExtendable +} +func (m *MyExtendable) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type OtherExtenable struct { + Field2 *int64 `protobuf:"varint,2,opt,name=Field2" json:"Field2,omitempty"` + Field13 *int64 `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + M *MyExtendable `protobuf:"bytes,1,opt,name=M" json:"M,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OtherExtenable) Reset() { *m = OtherExtenable{} } +func (*OtherExtenable) ProtoMessage() {} + +var extRange_OtherExtenable = []proto.ExtensionRange{ + {14, 16}, + {10, 12}, +} + +func (*OtherExtenable) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_OtherExtenable +} +func (m *OtherExtenable) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type NestedDefinition struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + EnumField *NestedDefinition_NestedEnum `protobuf:"varint,2,opt,name=EnumField,enum=test.NestedDefinition_NestedEnum" json:"EnumField,omitempty"` + NNM *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,3,opt,name=NNM" json:"NNM,omitempty"` + NM *NestedDefinition_NestedMessage `protobuf:"bytes,4,opt,name=NM" json:"NM,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition) Reset() { *m = NestedDefinition{} } +func (*NestedDefinition) ProtoMessage() {} + +type NestedDefinition_NestedMessage struct { + NestedField1 *uint64 `protobuf:"fixed64,1,opt,name=NestedField1" json:"NestedField1,omitempty"` + NNM *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,2,opt,name=NNM" json:"NNM,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition_NestedMessage) Reset() { *m = NestedDefinition_NestedMessage{} } +func (*NestedDefinition_NestedMessage) ProtoMessage() {} + +type NestedDefinition_NestedMessage_NestedNestedMsg struct { + NestedNestedField1 *string `protobuf:"bytes,10,opt,name=NestedNestedField1" json:"NestedNestedField1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Reset() { + *m = NestedDefinition_NestedMessage_NestedNestedMsg{} +} +func (*NestedDefinition_NestedMessage_NestedNestedMsg) ProtoMessage() {} + +type NestedScope struct { + A *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,1,opt,name=A" json:"A,omitempty"` + B *NestedDefinition_NestedEnum `protobuf:"varint,2,opt,name=B,enum=test.NestedDefinition_NestedEnum" json:"B,omitempty"` + C *NestedDefinition_NestedMessage `protobuf:"bytes,3,opt,name=C" json:"C,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedScope) Reset() { *m = NestedScope{} } +func (*NestedScope) ProtoMessage() {} + +type NinOptNativeDefault struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1,def=1234.1234" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2,def=1234.1234" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3,def=1234" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4,def=1234" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5,def=1234" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6,def=1234" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7,def=1234" json:"Field7,omitempty"` + Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8,def=1234" json:"Field8,omitempty"` + Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9,def=1234" json:"Field9,omitempty"` + Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10,def=1234" json:"Field10,omitempty"` + Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11,def=1234" json:"Field11,omitempty"` + Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12,def=1234" json:"Field12,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13,def=1" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14,def=1234" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNativeDefault) Reset() { *m = NinOptNativeDefault{} } +func (*NinOptNativeDefault) ProtoMessage() {} + +const Default_NinOptNativeDefault_Field1 float64 = 1234.1234 +const Default_NinOptNativeDefault_Field2 float32 = 1234.1234 +const Default_NinOptNativeDefault_Field3 int32 = 1234 +const Default_NinOptNativeDefault_Field4 int64 = 1234 +const Default_NinOptNativeDefault_Field5 uint32 = 1234 +const Default_NinOptNativeDefault_Field6 uint64 = 1234 +const Default_NinOptNativeDefault_Field7 int32 = 1234 +const Default_NinOptNativeDefault_Field8 int64 = 1234 +const Default_NinOptNativeDefault_Field9 uint32 = 1234 +const Default_NinOptNativeDefault_Field10 int32 = 1234 +const Default_NinOptNativeDefault_Field11 uint64 = 1234 +const Default_NinOptNativeDefault_Field12 int64 = 1234 +const Default_NinOptNativeDefault_Field13 bool = true +const Default_NinOptNativeDefault_Field14 string = "1234" + +func (m *NinOptNativeDefault) GetField1() float64 { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_NinOptNativeDefault_Field1 +} + +func (m *NinOptNativeDefault) GetField2() float32 { + if m != nil && m.Field2 != nil { + return *m.Field2 + } + return Default_NinOptNativeDefault_Field2 +} + +func (m *NinOptNativeDefault) GetField3() int32 { + if m != nil && m.Field3 != nil { + return *m.Field3 + } + return Default_NinOptNativeDefault_Field3 +} + +func (m *NinOptNativeDefault) GetField4() int64 { + if m != nil && m.Field4 != nil { + return *m.Field4 + } + return Default_NinOptNativeDefault_Field4 +} + +func (m *NinOptNativeDefault) GetField5() uint32 { + if m != nil && m.Field5 != nil { + return *m.Field5 + } + return Default_NinOptNativeDefault_Field5 +} + +func (m *NinOptNativeDefault) GetField6() uint64 { + if m != nil && m.Field6 != nil { + return *m.Field6 + } + return Default_NinOptNativeDefault_Field6 +} + +func (m *NinOptNativeDefault) GetField7() int32 { + if m != nil && m.Field7 != nil { + return *m.Field7 + } + return Default_NinOptNativeDefault_Field7 +} + +func (m *NinOptNativeDefault) GetField8() int64 { + if m != nil && m.Field8 != nil { + return *m.Field8 + } + return Default_NinOptNativeDefault_Field8 +} + +func (m *NinOptNativeDefault) GetField9() uint32 { + if m != nil && m.Field9 != nil { + return *m.Field9 + } + return Default_NinOptNativeDefault_Field9 +} + +func (m *NinOptNativeDefault) GetField10() int32 { + if m != nil && m.Field10 != nil { + return *m.Field10 + } + return Default_NinOptNativeDefault_Field10 +} + +func (m *NinOptNativeDefault) GetField11() uint64 { + if m != nil && m.Field11 != nil { + return *m.Field11 + } + return Default_NinOptNativeDefault_Field11 +} + +func (m *NinOptNativeDefault) GetField12() int64 { + if m != nil && m.Field12 != nil { + return *m.Field12 + } + return Default_NinOptNativeDefault_Field12 +} + +func (m *NinOptNativeDefault) GetField13() bool { + if m != nil && m.Field13 != nil { + return *m.Field13 + } + return Default_NinOptNativeDefault_Field13 +} + +func (m *NinOptNativeDefault) GetField14() string { + if m != nil && m.Field14 != nil { + return *m.Field14 + } + return Default_NinOptNativeDefault_Field14 +} + +func (m *NinOptNativeDefault) GetField15() []byte { + if m != nil { + return m.Field15 + } + return nil +} + +type CustomContainer struct { + CustomStruct NidOptCustom `protobuf:"bytes,1,opt,name=CustomStruct" json:"CustomStruct"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomContainer) Reset() { *m = CustomContainer{} } +func (*CustomContainer) ProtoMessage() {} + +type CustomNameNidOptNative struct { + FieldA float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + FieldB float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + FieldC int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3"` + FieldD int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4"` + FieldE uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5"` + FieldF uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + FieldG int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + FieldH int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8"` + FieldI uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9"` + FieldJ int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10"` + FieldK uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11"` + FieldL int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12"` + FieldM bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + FieldN string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + FieldO []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNidOptNative) Reset() { *m = CustomNameNidOptNative{} } +func (*CustomNameNidOptNative) ProtoMessage() {} + +type CustomNameNinOptNative struct { + FieldA *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + FieldB *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + FieldC *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + FieldD *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + FieldE *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + FieldF *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + FieldG *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + FieldH *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"` + FieldI *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"` + FieldJ *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"` + FieldK *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"` + FielL *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"` + FieldM *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + FieldN *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + FieldO []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinOptNative) Reset() { *m = CustomNameNinOptNative{} } +func (*CustomNameNinOptNative) ProtoMessage() {} + +type CustomNameNinRepNative struct { + FieldA []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + FieldB []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + FieldC []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + FieldD []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + FieldE []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + FieldF []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + FieldG []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + FieldH []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + FieldI []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + FieldJ []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + FieldK []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + FieldL []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + FieldM []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + FieldN []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + FieldO [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinRepNative) Reset() { *m = CustomNameNinRepNative{} } +func (*CustomNameNinRepNative) ProtoMessage() {} + +type CustomNameNinStruct struct { + FieldA *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + FieldB *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + FieldC *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + FieldD []*NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4,omitempty"` + FieldE *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + FieldF *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + FieldG *NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"` + FieldH *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + FieldI *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + FieldJ []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinStruct) Reset() { *m = CustomNameNinStruct{} } +func (*CustomNameNinStruct) ProtoMessage() {} + +type CustomNameCustomType struct { + FieldA *Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id,omitempty"` + FieldB *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + FieldC []Uuid `protobuf:"bytes,3,rep,name=Ids,customtype=Uuid" json:"Ids,omitempty"` + FieldD []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,4,rep,name=Values,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Values,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameCustomType) Reset() { *m = CustomNameCustomType{} } +func (*CustomNameCustomType) ProtoMessage() {} + +type CustomNameNinEmbeddedStructUnion struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + FieldA *NinOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + FieldB *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinEmbeddedStructUnion) Reset() { *m = CustomNameNinEmbeddedStructUnion{} } +func (*CustomNameNinEmbeddedStructUnion) ProtoMessage() {} + +type CustomNameEnum struct { + FieldA *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + FieldB []TheTestEnum `protobuf:"varint,2,rep,name=Field2,enum=test.TheTestEnum" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameEnum) Reset() { *m = CustomNameEnum{} } +func (*CustomNameEnum) ProtoMessage() {} + +type NoExtensionsMap struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + XXX_extensions []byte `protobuf:"bytes,0,opt" json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NoExtensionsMap) Reset() { *m = NoExtensionsMap{} } +func (*NoExtensionsMap) ProtoMessage() {} + +var extRange_NoExtensionsMap = []proto.ExtensionRange{ + {100, 199}, +} + +func (*NoExtensionsMap) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_NoExtensionsMap +} +func (m *NoExtensionsMap) GetExtensions() *[]byte { + if m.XXX_extensions == nil { + m.XXX_extensions = make([]byte, 0) + } + return &m.XXX_extensions +} + +type Unrecognized struct { + Field1 *string `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *Unrecognized) Reset() { *m = Unrecognized{} } +func (*Unrecognized) ProtoMessage() {} + +type UnrecognizedWithInner struct { + Embedded []*UnrecognizedWithInner_Inner `protobuf:"bytes,1,rep,name=embedded" json:"embedded,omitempty"` + Field2 *string `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnrecognizedWithInner) Reset() { *m = UnrecognizedWithInner{} } +func (*UnrecognizedWithInner) ProtoMessage() {} + +type UnrecognizedWithInner_Inner struct { + Field1 *uint32 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *UnrecognizedWithInner_Inner) Reset() { *m = UnrecognizedWithInner_Inner{} } +func (*UnrecognizedWithInner_Inner) ProtoMessage() {} + +type UnrecognizedWithEmbed struct { + UnrecognizedWithEmbed_Embedded `protobuf:"bytes,1,opt,name=embedded,embedded=embedded" json:"embedded"` + Field2 *string `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnrecognizedWithEmbed) Reset() { *m = UnrecognizedWithEmbed{} } +func (*UnrecognizedWithEmbed) ProtoMessage() {} + +type UnrecognizedWithEmbed_Embedded struct { + Field1 *uint32 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *UnrecognizedWithEmbed_Embedded) Reset() { *m = UnrecognizedWithEmbed_Embedded{} } +func (*UnrecognizedWithEmbed_Embedded) ProtoMessage() {} + +var E_FieldA = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*float64)(nil), + Field: 100, + Name: "test.FieldA", + Tag: "fixed64,100,opt,name=FieldA", +} + +var E_FieldB = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*NinOptNative)(nil), + Field: 101, + Name: "test.FieldB", + Tag: "bytes,101,opt,name=FieldB", +} + +var E_FieldC = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*NinEmbeddedStruct)(nil), + Field: 102, + Name: "test.FieldC", + Tag: "bytes,102,opt,name=FieldC", +} + +var E_FieldA1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*float64)(nil), + Field: 100, + Name: "test.FieldA1", + Tag: "fixed64,100,opt,name=FieldA1", +} + +var E_FieldB1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*NinOptNative)(nil), + Field: 101, + Name: "test.FieldB1", + Tag: "bytes,101,opt,name=FieldB1", +} + +var E_FieldC1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*NinEmbeddedStruct)(nil), + Field: 102, + Name: "test.FieldC1", + Tag: "bytes,102,opt,name=FieldC1", +} + +func init() { + proto.RegisterEnum("test.TheTestEnum", TheTestEnum_name, TheTestEnum_value) + proto.RegisterEnum("test.AnotherTestEnum", AnotherTestEnum_name, AnotherTestEnum_value) + proto.RegisterEnum("test.NestedDefinition_NestedEnum", NestedDefinition_NestedEnum_name, NestedDefinition_NestedEnum_value) + proto.RegisterExtension(E_FieldA) + proto.RegisterExtension(E_FieldB) + proto.RegisterExtension(E_FieldC) + proto.RegisterExtension(E_FieldA1) + proto.RegisterExtension(E_FieldB1) + proto.RegisterExtension(E_FieldC1) +} +func (this *NidOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepPackedNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepPackedNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidEmbeddedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinEmbeddedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidNestedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinNestedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomDash) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNativeUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinEmbeddedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinNestedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Tree) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *OrBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AndBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Leaf) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *DeepTree) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *ADeepBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AndDeepBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *DeepLeaf) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Nil) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptEnumDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AnotherNinOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AnotherNinOptEnumDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Timer) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *MyExtendable) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *OtherExtenable) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition_NestedMessage) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedScope) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNativeDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomContainer) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNidOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameCustomType) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinEmbeddedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NoExtensionsMap) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Unrecognized) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithInner) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithInner_Inner) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithEmbed) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithEmbed_Embedded) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func ThetestDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unmarshaler/thetest.proto"), + Package: func(v string) *string { return &v }("test"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NinRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NidOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }, {Name: func(v string) *string { return &v }("NidNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidRepStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStruct"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinRepStruct"), + }}, + }, {Name: func(v string) *string { return &v }("NidOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomDash"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x64, 0x61, 0x73, 0x68, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NidRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinOptStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinNestedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNativeUnion"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStructUnion"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStructUnion"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Tree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Or"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.OrBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Leaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("OrBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Leaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("StrValue"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepTree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.ADeepBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndDeepBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepLeaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("ADeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndDeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepLeaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Tree"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Nil")}, {Name: func(v string) *string { return &v }("NidOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NidRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + DefaultValue: func(v string) *string { return &v }("C"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + DefaultValue: func(v string) *string { return &v }("E"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Timer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Time1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Time2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Data"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("MyExtendable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("OtherExtenable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("M"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.MyExtendable"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(14), + End: func(v int32) *int32 { return &v }(17), + }, {Start: func(v int32) *int32 { return &v }(10), + End: func(v int32) *int32 { return &v }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("NestedDefinition"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("EnumField"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("NM"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedMessage"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedField1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedMsg"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedField1"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("NestedEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_NESTED"), + Number: func(v int32) *int32 { return &v }(1), + }}, + }}, + }, {Name: func(v string) *string { return &v }("NestedScope"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("true"), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("CustomContainer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("CustomStruct"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptCustom"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x5, 0x46, 0x69, 0x65, 0x6c, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameCustomType"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Ids"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Values"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("CustomNameEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + }, {Name: func(v string) *string { return &v }("NoExtensionsMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0}), 64025: proto.NewExtension([]byte{0xc8, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Unrecognized"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithInner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithInner.Inner"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Inner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithEmbed"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithEmbed.Embedded"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Embedded"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("TheTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }, {Name: func(v string) *string { return &v }("AnotherTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("D"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("E"), + Number: func(v int32) *int32 { return &v }(11), + }}, + Options: &google_protobuf.EnumOptions{XXX_extensions: map[int32]proto.Extension{62001: proto.NewExtension([]byte{0x88, 0xa3, 0x1e, 0x0})}}, + }}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("FieldA"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldB"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldC"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldA1"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldB1"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldC1"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (x TheTestEnum) String() string { + s, ok := TheTestEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x AnotherTestEnum) String() string { + s, ok := AnotherTestEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x NestedDefinition_NestedEnum) String() string { + s, ok := NestedDefinition_NestedEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *NidOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptNative) + if !ok { + return fmt.Errorf("that is not of type *NidOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptNativebut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if this.Field2 != that1.Field2 { + return false + } + if this.Field3 != that1.Field3 { + return false + } + if this.Field4 != that1.Field4 { + return false + } + if this.Field5 != that1.Field5 { + return false + } + if this.Field6 != that1.Field6 { + return false + } + if this.Field7 != that1.Field7 { + return false + } + if this.Field8 != that1.Field8 { + return false + } + if this.Field9 != that1.Field9 { + return false + } + if this.Field10 != that1.Field10 { + return false + } + if this.Field11 != that1.Field11 { + return false + } + if this.Field12 != that1.Field12 { + return false + } + if this.Field13 != that1.Field13 { + return false + } + if this.Field14 != that1.Field14 { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNative) + if !ok { + return fmt.Errorf("that is not of type *NinOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativebut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", *this.Field8, *that1.Field8) + } + } else if this.Field8 != nil { + return fmt.Errorf("this.Field8 == nil && that.Field8 != nil") + } else if that1.Field8 != nil { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", *this.Field9, *that1.Field9) + } + } else if this.Field9 != nil { + return fmt.Errorf("this.Field9 == nil && that.Field9 != nil") + } else if that1.Field9 != nil { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", *this.Field10, *that1.Field10) + } + } else if this.Field10 != nil { + return fmt.Errorf("this.Field10 == nil && that.Field10 != nil") + } else if that1.Field10 != nil { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", *this.Field11, *that1.Field11) + } + } else if this.Field11 != nil { + return fmt.Errorf("this.Field11 == nil && that.Field11 != nil") + } else if that1.Field11 != nil { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", *this.Field12, *that1.Field12) + } + } else if this.Field12 != nil { + return fmt.Errorf("this.Field12 == nil && that.Field12 != nil") + } else if that1.Field12 != nil { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return false + } + } else if this.Field8 != nil { + return false + } else if that1.Field8 != nil { + return false + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return false + } + } else if this.Field9 != nil { + return false + } else if that1.Field9 != nil { + return false + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return false + } + } else if this.Field10 != nil { + return false + } else if that1.Field10 != nil { + return false + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return false + } + } else if this.Field11 != nil { + return false + } else if that1.Field11 != nil { + return false + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return false + } + } else if this.Field12 != nil { + return false + } else if that1.Field12 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepNative) + if !ok { + return fmt.Errorf("that is not of type *NidRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepNative) + if !ok { + return fmt.Errorf("that is not of type *NinRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepPackedNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepPackedNative) + if !ok { + return fmt.Errorf("that is not of type *NidRepPackedNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepPackedNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepPackedNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepPackedNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepPackedNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepPackedNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepPackedNative) + if !ok { + return fmt.Errorf("that is not of type *NinRepPackedNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepPackedNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepPackedNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepPackedNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepPackedNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptStruct) + if !ok { + return fmt.Errorf("that is not of type *NidOptStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptStructbut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(&that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(&that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if !this.Field8.Equal(&that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if this.Field2 != that1.Field2 { + return false + } + if !this.Field3.Equal(&that1.Field3) { + return false + } + if !this.Field4.Equal(&that1.Field4) { + return false + } + if this.Field6 != that1.Field6 { + return false + } + if this.Field7 != that1.Field7 { + return false + } + if !this.Field8.Equal(&that1.Field8) { + return false + } + if this.Field13 != that1.Field13 { + return false + } + if this.Field14 != that1.Field14 { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptStruct) + if !ok { + return fmt.Errorf("that is not of type *NinOptStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptStructbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if !this.Field8.Equal(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !this.Field4.Equal(that1.Field4) { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if !this.Field8.Equal(that1.Field8) { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepStruct) + if !ok { + return fmt.Errorf("that is not of type *NidRepStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepStructbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if !this.Field3[i].Equal(&that1.Field3[i]) { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if !this.Field4[i].Equal(&that1.Field4[i]) { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if !this.Field8[i].Equal(&that1.Field8[i]) { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if !this.Field3[i].Equal(&that1.Field3[i]) { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if !this.Field4[i].Equal(&that1.Field4[i]) { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if !this.Field8[i].Equal(&that1.Field8[i]) { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepStruct) + if !ok { + return fmt.Errorf("that is not of type *NinRepStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepStructbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if !this.Field3[i].Equal(that1.Field3[i]) { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if !this.Field4[i].Equal(that1.Field4[i]) { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if !this.Field8[i].Equal(that1.Field8[i]) { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if !this.Field3[i].Equal(that1.Field3[i]) { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if !this.Field4[i].Equal(that1.Field4[i]) { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if !this.Field8[i].Equal(that1.Field8[i]) { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidEmbeddedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidEmbeddedStruct) + if !ok { + return fmt.Errorf("that is not of type *NidEmbeddedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidEmbeddedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidEmbeddedStructbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(&that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidEmbeddedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidEmbeddedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(&that1.Field200) { + return false + } + if this.Field210 != that1.Field210 { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinEmbeddedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinEmbeddedStruct) + if !ok { + return fmt.Errorf("that is not of type *NinEmbeddedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinEmbeddedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinEmbeddedStructbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", *this.Field210, *that1.Field210) + } + } else if this.Field210 != nil { + return fmt.Errorf("this.Field210 == nil && that.Field210 != nil") + } else if that1.Field210 != nil { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinEmbeddedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinEmbeddedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(that1.Field200) { + return false + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return false + } + } else if this.Field210 != nil { + return false + } else if that1.Field210 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidNestedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidNestedStruct) + if !ok { + return fmt.Errorf("that is not of type *NidNestedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidNestedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidNestedStructbut is not nil && this == nil") + } + if !this.Field1.Equal(&that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if !this.Field2[i].Equal(&that1.Field2[i]) { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidNestedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidNestedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(&that1.Field1) { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if !this.Field2[i].Equal(&that1.Field2[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinNestedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinNestedStruct) + if !ok { + return fmt.Errorf("that is not of type *NinNestedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinNestedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinNestedStructbut is not nil && this == nil") + } + if !this.Field1.Equal(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if !this.Field2[i].Equal(that1.Field2[i]) { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinNestedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinNestedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(that1.Field1) { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if !this.Field2[i].Equal(that1.Field2[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptCustom) + if !ok { + return fmt.Errorf("that is not of type *NidOptCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptCustombut is not nil && this == nil") + } + if !this.Id.Equal(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id) + } + if !this.Value.Equal(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Id.Equal(that1.Id) { + return false + } + if !this.Value.Equal(that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomDash) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomDash) + if !ok { + return fmt.Errorf("that is not of type *CustomDash") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomDash but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomDashbut is not nil && this == nil") + } + if that1.Value == nil { + if this.Value != nil { + return fmt.Errorf("this.Value != nil && that1.Value == nil") + } + } else if !this.Value.Equal(*that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomDash) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomDash) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Value == nil { + if this.Value != nil { + return false + } + } else if !this.Value.Equal(*that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptCustom) + if !ok { + return fmt.Errorf("that is not of type *NinOptCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptCustombut is not nil && this == nil") + } + if that1.Id == nil { + if this.Id != nil { + return fmt.Errorf("this.Id != nil && that1.Id == nil") + } + } else if !this.Id.Equal(*that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id) + } + if that1.Value == nil { + if this.Value != nil { + return fmt.Errorf("this.Value != nil && that1.Value == nil") + } + } else if !this.Value.Equal(*that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Id == nil { + if this.Id != nil { + return false + } + } else if !this.Id.Equal(*that1.Id) { + return false + } + if that1.Value == nil { + if this.Value != nil { + return false + } + } else if !this.Value.Equal(*that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepCustom) + if !ok { + return fmt.Errorf("that is not of type *NidRepCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepCustombut is not nil && this == nil") + } + if len(this.Id) != len(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", len(this.Id), len(that1.Id)) + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return fmt.Errorf("Id this[%v](%v) Not Equal that[%v](%v)", i, this.Id[i], i, that1.Id[i]) + } + } + if len(this.Value) != len(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", len(this.Value), len(that1.Value)) + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return fmt.Errorf("Value this[%v](%v) Not Equal that[%v](%v)", i, this.Value[i], i, that1.Value[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Id) != len(that1.Id) { + return false + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return false + } + } + if len(this.Value) != len(that1.Value) { + return false + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepCustom) + if !ok { + return fmt.Errorf("that is not of type *NinRepCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepCustombut is not nil && this == nil") + } + if len(this.Id) != len(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", len(this.Id), len(that1.Id)) + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return fmt.Errorf("Id this[%v](%v) Not Equal that[%v](%v)", i, this.Id[i], i, that1.Id[i]) + } + } + if len(this.Value) != len(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", len(this.Value), len(that1.Value)) + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return fmt.Errorf("Value this[%v](%v) Not Equal that[%v](%v)", i, this.Value[i], i, that1.Value[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Id) != len(that1.Id) { + return false + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return false + } + } + if len(this.Value) != len(that1.Value) { + return false + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNativeUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNativeUnion) + if !ok { + return fmt.Errorf("that is not of type *NinOptNativeUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNativeUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativeUnionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNativeUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNativeUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinOptStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptStructUnionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !this.Field4.Equal(that1.Field4) { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinEmbeddedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinEmbeddedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinEmbeddedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinEmbeddedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinEmbeddedStructUnionbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", *this.Field210, *that1.Field210) + } + } else if this.Field210 != nil { + return fmt.Errorf("this.Field210 == nil && that.Field210 != nil") + } else if that1.Field210 != nil { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinEmbeddedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinEmbeddedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(that1.Field200) { + return false + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return false + } + } else if this.Field210 != nil { + return false + } else if that1.Field210 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinNestedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinNestedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinNestedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinNestedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinNestedStructUnionbut is not nil && this == nil") + } + if !this.Field1.Equal(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !this.Field2.Equal(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinNestedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinNestedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(that1.Field1) { + return false + } + if !this.Field2.Equal(that1.Field2) { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Tree) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Tree) + if !ok { + return fmt.Errorf("that is not of type *Tree") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Tree but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Treebut is not nil && this == nil") + } + if !this.Or.Equal(that1.Or) { + return fmt.Errorf("Or this(%v) Not Equal that(%v)", this.Or, that1.Or) + } + if !this.And.Equal(that1.And) { + return fmt.Errorf("And this(%v) Not Equal that(%v)", this.And, that1.And) + } + if !this.Leaf.Equal(that1.Leaf) { + return fmt.Errorf("Leaf this(%v) Not Equal that(%v)", this.Leaf, that1.Leaf) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Tree) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Tree) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Or.Equal(that1.Or) { + return false + } + if !this.And.Equal(that1.And) { + return false + } + if !this.Leaf.Equal(that1.Leaf) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OrBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OrBranch) + if !ok { + return fmt.Errorf("that is not of type *OrBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OrBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OrBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OrBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OrBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AndBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AndBranch) + if !ok { + return fmt.Errorf("that is not of type *AndBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AndBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AndBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AndBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AndBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Leaf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Leaf) + if !ok { + return fmt.Errorf("that is not of type *Leaf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Leaf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Leafbut is not nil && this == nil") + } + if this.Value != that1.Value { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if this.StrValue != that1.StrValue { + return fmt.Errorf("StrValue this(%v) Not Equal that(%v)", this.StrValue, that1.StrValue) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Leaf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Leaf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Value != that1.Value { + return false + } + if this.StrValue != that1.StrValue { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *DeepTree) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*DeepTree) + if !ok { + return fmt.Errorf("that is not of type *DeepTree") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *DeepTree but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *DeepTreebut is not nil && this == nil") + } + if !this.Down.Equal(that1.Down) { + return fmt.Errorf("Down this(%v) Not Equal that(%v)", this.Down, that1.Down) + } + if !this.And.Equal(that1.And) { + return fmt.Errorf("And this(%v) Not Equal that(%v)", this.And, that1.And) + } + if !this.Leaf.Equal(that1.Leaf) { + return fmt.Errorf("Leaf this(%v) Not Equal that(%v)", this.Leaf, that1.Leaf) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *DeepTree) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*DeepTree) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Down.Equal(that1.Down) { + return false + } + if !this.And.Equal(that1.And) { + return false + } + if !this.Leaf.Equal(that1.Leaf) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *ADeepBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*ADeepBranch) + if !ok { + return fmt.Errorf("that is not of type *ADeepBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *ADeepBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *ADeepBranchbut is not nil && this == nil") + } + if !this.Down.Equal(&that1.Down) { + return fmt.Errorf("Down this(%v) Not Equal that(%v)", this.Down, that1.Down) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *ADeepBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*ADeepBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Down.Equal(&that1.Down) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AndDeepBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AndDeepBranch) + if !ok { + return fmt.Errorf("that is not of type *AndDeepBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AndDeepBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AndDeepBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AndDeepBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AndDeepBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *DeepLeaf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*DeepLeaf) + if !ok { + return fmt.Errorf("that is not of type *DeepLeaf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *DeepLeaf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *DeepLeafbut is not nil && this == nil") + } + if !this.Tree.Equal(&that1.Tree) { + return fmt.Errorf("Tree this(%v) Not Equal that(%v)", this.Tree, that1.Tree) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *DeepLeaf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*DeepLeaf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Tree.Equal(&that1.Tree) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Nil) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Nil) + if !ok { + return fmt.Errorf("that is not of type *Nil") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Nil but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Nilbut is not nil && this == nil") + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Nil) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Nil) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptEnum) + if !ok { + return fmt.Errorf("that is not of type *NidOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptEnumbut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptEnum) + if !ok { + return fmt.Errorf("that is not of type *NinOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptEnumbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepEnum) + if !ok { + return fmt.Errorf("that is not of type *NidRepEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepEnumbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepEnum) + if !ok { + return fmt.Errorf("that is not of type *NinRepEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepEnumbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptEnumDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptEnumDefault) + if !ok { + return fmt.Errorf("that is not of type *NinOptEnumDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptEnumDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptEnumDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptEnumDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptEnumDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AnotherNinOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AnotherNinOptEnum) + if !ok { + return fmt.Errorf("that is not of type *AnotherNinOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AnotherNinOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AnotherNinOptEnumbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AnotherNinOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AnotherNinOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AnotherNinOptEnumDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AnotherNinOptEnumDefault) + if !ok { + return fmt.Errorf("that is not of type *AnotherNinOptEnumDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AnotherNinOptEnumDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AnotherNinOptEnumDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AnotherNinOptEnumDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AnotherNinOptEnumDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Timer) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Timer) + if !ok { + return fmt.Errorf("that is not of type *Timer") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Timer but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Timerbut is not nil && this == nil") + } + if this.Time1 != that1.Time1 { + return fmt.Errorf("Time1 this(%v) Not Equal that(%v)", this.Time1, that1.Time1) + } + if this.Time2 != that1.Time2 { + return fmt.Errorf("Time2 this(%v) Not Equal that(%v)", this.Time2, that1.Time2) + } + if !bytes.Equal(this.Data, that1.Data) { + return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Timer) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Timer) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Time1 != that1.Time1 { + return false + } + if this.Time2 != that1.Time2 { + return false + } + if !bytes.Equal(this.Data, that1.Data) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *MyExtendable) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*MyExtendable) + if !ok { + return fmt.Errorf("that is not of type *MyExtendable") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *MyExtendable but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *MyExtendablebut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return fmt.Errorf("XXX_extensions this[%v](%v) Not Equal that[%v](%v)", k, this.XXX_extensions[k], k, that1.XXX_extensions[k]) + } + } else { + return fmt.Errorf("XXX_extensions[%v] Not In that", k) + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return fmt.Errorf("XXX_extensions[%v] Not In this", k) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *MyExtendable) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*MyExtendable) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return false + } + } else { + return false + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OtherExtenable) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OtherExtenable) + if !ok { + return fmt.Errorf("that is not of type *OtherExtenable") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OtherExtenable but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OtherExtenablebut is not nil && this == nil") + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if !this.M.Equal(that1.M) { + return fmt.Errorf("M this(%v) Not Equal that(%v)", this.M, that1.M) + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return fmt.Errorf("XXX_extensions this[%v](%v) Not Equal that[%v](%v)", k, this.XXX_extensions[k], k, that1.XXX_extensions[k]) + } + } else { + return fmt.Errorf("XXX_extensions[%v] Not In that", k) + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return fmt.Errorf("XXX_extensions[%v] Not In this", k) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OtherExtenable) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OtherExtenable) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if !this.M.Equal(that1.M) { + return false + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return false + } + } else { + return false + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinitionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.EnumField != nil && that1.EnumField != nil { + if *this.EnumField != *that1.EnumField { + return fmt.Errorf("EnumField this(%v) Not Equal that(%v)", *this.EnumField, *that1.EnumField) + } + } else if this.EnumField != nil { + return fmt.Errorf("this.EnumField == nil && that.EnumField != nil") + } else if that1.EnumField != nil { + return fmt.Errorf("EnumField this(%v) Not Equal that(%v)", this.EnumField, that1.EnumField) + } + if !this.NNM.Equal(that1.NNM) { + return fmt.Errorf("NNM this(%v) Not Equal that(%v)", this.NNM, that1.NNM) + } + if !this.NM.Equal(that1.NM) { + return fmt.Errorf("NM this(%v) Not Equal that(%v)", this.NM, that1.NM) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.EnumField != nil && that1.EnumField != nil { + if *this.EnumField != *that1.EnumField { + return false + } + } else if this.EnumField != nil { + return false + } else if that1.EnumField != nil { + return false + } + if !this.NNM.Equal(that1.NNM) { + return false + } + if !this.NM.Equal(that1.NM) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition_NestedMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition_NestedMessage) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition_NestedMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition_NestedMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinition_NestedMessagebut is not nil && this == nil") + } + if this.NestedField1 != nil && that1.NestedField1 != nil { + if *this.NestedField1 != *that1.NestedField1 { + return fmt.Errorf("NestedField1 this(%v) Not Equal that(%v)", *this.NestedField1, *that1.NestedField1) + } + } else if this.NestedField1 != nil { + return fmt.Errorf("this.NestedField1 == nil && that.NestedField1 != nil") + } else if that1.NestedField1 != nil { + return fmt.Errorf("NestedField1 this(%v) Not Equal that(%v)", this.NestedField1, that1.NestedField1) + } + if !this.NNM.Equal(that1.NNM) { + return fmt.Errorf("NNM this(%v) Not Equal that(%v)", this.NNM, that1.NNM) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition_NestedMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition_NestedMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.NestedField1 != nil && that1.NestedField1 != nil { + if *this.NestedField1 != *that1.NestedField1 { + return false + } + } else if this.NestedField1 != nil { + return false + } else if that1.NestedField1 != nil { + return false + } + if !this.NNM.Equal(that1.NNM) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition_NestedMessage_NestedNestedMsg) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition_NestedMessage_NestedNestedMsg") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition_NestedMessage_NestedNestedMsg but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinition_NestedMessage_NestedNestedMsgbut is not nil && this == nil") + } + if this.NestedNestedField1 != nil && that1.NestedNestedField1 != nil { + if *this.NestedNestedField1 != *that1.NestedNestedField1 { + return fmt.Errorf("NestedNestedField1 this(%v) Not Equal that(%v)", *this.NestedNestedField1, *that1.NestedNestedField1) + } + } else if this.NestedNestedField1 != nil { + return fmt.Errorf("this.NestedNestedField1 == nil && that.NestedNestedField1 != nil") + } else if that1.NestedNestedField1 != nil { + return fmt.Errorf("NestedNestedField1 this(%v) Not Equal that(%v)", this.NestedNestedField1, that1.NestedNestedField1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition_NestedMessage_NestedNestedMsg) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.NestedNestedField1 != nil && that1.NestedNestedField1 != nil { + if *this.NestedNestedField1 != *that1.NestedNestedField1 { + return false + } + } else if this.NestedNestedField1 != nil { + return false + } else if that1.NestedNestedField1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedScope) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedScope) + if !ok { + return fmt.Errorf("that is not of type *NestedScope") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedScope but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedScopebut is not nil && this == nil") + } + if !this.A.Equal(that1.A) { + return fmt.Errorf("A this(%v) Not Equal that(%v)", this.A, that1.A) + } + if this.B != nil && that1.B != nil { + if *this.B != *that1.B { + return fmt.Errorf("B this(%v) Not Equal that(%v)", *this.B, *that1.B) + } + } else if this.B != nil { + return fmt.Errorf("this.B == nil && that.B != nil") + } else if that1.B != nil { + return fmt.Errorf("B this(%v) Not Equal that(%v)", this.B, that1.B) + } + if !this.C.Equal(that1.C) { + return fmt.Errorf("C this(%v) Not Equal that(%v)", this.C, that1.C) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedScope) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedScope) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.A.Equal(that1.A) { + return false + } + if this.B != nil && that1.B != nil { + if *this.B != *that1.B { + return false + } + } else if this.B != nil { + return false + } else if that1.B != nil { + return false + } + if !this.C.Equal(that1.C) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNativeDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNativeDefault) + if !ok { + return fmt.Errorf("that is not of type *NinOptNativeDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNativeDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativeDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", *this.Field8, *that1.Field8) + } + } else if this.Field8 != nil { + return fmt.Errorf("this.Field8 == nil && that.Field8 != nil") + } else if that1.Field8 != nil { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", *this.Field9, *that1.Field9) + } + } else if this.Field9 != nil { + return fmt.Errorf("this.Field9 == nil && that.Field9 != nil") + } else if that1.Field9 != nil { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", *this.Field10, *that1.Field10) + } + } else if this.Field10 != nil { + return fmt.Errorf("this.Field10 == nil && that.Field10 != nil") + } else if that1.Field10 != nil { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", *this.Field11, *that1.Field11) + } + } else if this.Field11 != nil { + return fmt.Errorf("this.Field11 == nil && that.Field11 != nil") + } else if that1.Field11 != nil { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", *this.Field12, *that1.Field12) + } + } else if this.Field12 != nil { + return fmt.Errorf("this.Field12 == nil && that.Field12 != nil") + } else if that1.Field12 != nil { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNativeDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNativeDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return false + } + } else if this.Field8 != nil { + return false + } else if that1.Field8 != nil { + return false + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return false + } + } else if this.Field9 != nil { + return false + } else if that1.Field9 != nil { + return false + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return false + } + } else if this.Field10 != nil { + return false + } else if that1.Field10 != nil { + return false + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return false + } + } else if this.Field11 != nil { + return false + } else if that1.Field11 != nil { + return false + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return false + } + } else if this.Field12 != nil { + return false + } else if that1.Field12 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomContainer) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomContainer) + if !ok { + return fmt.Errorf("that is not of type *CustomContainer") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomContainer but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomContainerbut is not nil && this == nil") + } + if !this.CustomStruct.Equal(&that1.CustomStruct) { + return fmt.Errorf("CustomStruct this(%v) Not Equal that(%v)", this.CustomStruct, that1.CustomStruct) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomContainer) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomContainer) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.CustomStruct.Equal(&that1.CustomStruct) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNidOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNidOptNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNidOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNidOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNidOptNativebut is not nil && this == nil") + } + if this.FieldA != that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if this.FieldC != that1.FieldC { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if this.FieldD != that1.FieldD { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", this.FieldD, that1.FieldD) + } + if this.FieldE != that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if this.FieldG != that1.FieldG { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if this.FieldJ != that1.FieldJ { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if this.FieldK != that1.FieldK { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", this.FieldK, that1.FieldK) + } + if this.FieldL != that1.FieldL { + return fmt.Errorf("FieldL this(%v) Not Equal that(%v)", this.FieldL, that1.FieldL) + } + if this.FieldM != that1.FieldM { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", this.FieldM, that1.FieldM) + } + if this.FieldN != that1.FieldN { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", this.FieldN, that1.FieldN) + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", this.FieldO, that1.FieldO) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNidOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNidOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != that1.FieldA { + return false + } + if this.FieldB != that1.FieldB { + return false + } + if this.FieldC != that1.FieldC { + return false + } + if this.FieldD != that1.FieldD { + return false + } + if this.FieldE != that1.FieldE { + return false + } + if this.FieldF != that1.FieldF { + return false + } + if this.FieldG != that1.FieldG { + return false + } + if this.FieldH != that1.FieldH { + return false + } + if this.FieldI != that1.FieldI { + return false + } + if this.FieldJ != that1.FieldJ { + return false + } + if this.FieldK != that1.FieldK { + return false + } + if this.FieldL != that1.FieldL { + return false + } + if this.FieldM != that1.FieldM { + return false + } + if this.FieldN != that1.FieldN { + return false + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinOptNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinOptNativebut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if this.FieldC != nil && that1.FieldC != nil { + if *this.FieldC != *that1.FieldC { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", *this.FieldC, *that1.FieldC) + } + } else if this.FieldC != nil { + return fmt.Errorf("this.FieldC == nil && that.FieldC != nil") + } else if that1.FieldC != nil { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if this.FieldD != nil && that1.FieldD != nil { + if *this.FieldD != *that1.FieldD { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", *this.FieldD, *that1.FieldD) + } + } else if this.FieldD != nil { + return fmt.Errorf("this.FieldD == nil && that.FieldD != nil") + } else if that1.FieldD != nil { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", this.FieldD, that1.FieldD) + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", *this.FieldE, *that1.FieldE) + } + } else if this.FieldE != nil { + return fmt.Errorf("this.FieldE == nil && that.FieldE != nil") + } else if that1.FieldE != nil { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", *this.FieldF, *that1.FieldF) + } + } else if this.FieldF != nil { + return fmt.Errorf("this.FieldF == nil && that.FieldF != nil") + } else if that1.FieldF != nil { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if this.FieldG != nil && that1.FieldG != nil { + if *this.FieldG != *that1.FieldG { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", *this.FieldG, *that1.FieldG) + } + } else if this.FieldG != nil { + return fmt.Errorf("this.FieldG == nil && that.FieldG != nil") + } else if that1.FieldG != nil { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", *this.FieldH, *that1.FieldH) + } + } else if this.FieldH != nil { + return fmt.Errorf("this.FieldH == nil && that.FieldH != nil") + } else if that1.FieldH != nil { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", *this.FieldI, *that1.FieldI) + } + } else if this.FieldI != nil { + return fmt.Errorf("this.FieldI == nil && that.FieldI != nil") + } else if that1.FieldI != nil { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if this.FieldJ != nil && that1.FieldJ != nil { + if *this.FieldJ != *that1.FieldJ { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", *this.FieldJ, *that1.FieldJ) + } + } else if this.FieldJ != nil { + return fmt.Errorf("this.FieldJ == nil && that.FieldJ != nil") + } else if that1.FieldJ != nil { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if this.FieldK != nil && that1.FieldK != nil { + if *this.FieldK != *that1.FieldK { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", *this.FieldK, *that1.FieldK) + } + } else if this.FieldK != nil { + return fmt.Errorf("this.FieldK == nil && that.FieldK != nil") + } else if that1.FieldK != nil { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", this.FieldK, that1.FieldK) + } + if this.FielL != nil && that1.FielL != nil { + if *this.FielL != *that1.FielL { + return fmt.Errorf("FielL this(%v) Not Equal that(%v)", *this.FielL, *that1.FielL) + } + } else if this.FielL != nil { + return fmt.Errorf("this.FielL == nil && that.FielL != nil") + } else if that1.FielL != nil { + return fmt.Errorf("FielL this(%v) Not Equal that(%v)", this.FielL, that1.FielL) + } + if this.FieldM != nil && that1.FieldM != nil { + if *this.FieldM != *that1.FieldM { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", *this.FieldM, *that1.FieldM) + } + } else if this.FieldM != nil { + return fmt.Errorf("this.FieldM == nil && that.FieldM != nil") + } else if that1.FieldM != nil { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", this.FieldM, that1.FieldM) + } + if this.FieldN != nil && that1.FieldN != nil { + if *this.FieldN != *that1.FieldN { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", *this.FieldN, *that1.FieldN) + } + } else if this.FieldN != nil { + return fmt.Errorf("this.FieldN == nil && that.FieldN != nil") + } else if that1.FieldN != nil { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", this.FieldN, that1.FieldN) + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", this.FieldO, that1.FieldO) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if this.FieldC != nil && that1.FieldC != nil { + if *this.FieldC != *that1.FieldC { + return false + } + } else if this.FieldC != nil { + return false + } else if that1.FieldC != nil { + return false + } + if this.FieldD != nil && that1.FieldD != nil { + if *this.FieldD != *that1.FieldD { + return false + } + } else if this.FieldD != nil { + return false + } else if that1.FieldD != nil { + return false + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return false + } + } else if this.FieldE != nil { + return false + } else if that1.FieldE != nil { + return false + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return false + } + } else if this.FieldF != nil { + return false + } else if that1.FieldF != nil { + return false + } + if this.FieldG != nil && that1.FieldG != nil { + if *this.FieldG != *that1.FieldG { + return false + } + } else if this.FieldG != nil { + return false + } else if that1.FieldG != nil { + return false + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return false + } + } else if this.FieldH != nil { + return false + } else if that1.FieldH != nil { + return false + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return false + } + } else if this.FieldI != nil { + return false + } else if that1.FieldI != nil { + return false + } + if this.FieldJ != nil && that1.FieldJ != nil { + if *this.FieldJ != *that1.FieldJ { + return false + } + } else if this.FieldJ != nil { + return false + } else if that1.FieldJ != nil { + return false + } + if this.FieldK != nil && that1.FieldK != nil { + if *this.FieldK != *that1.FieldK { + return false + } + } else if this.FieldK != nil { + return false + } else if that1.FieldK != nil { + return false + } + if this.FielL != nil && that1.FielL != nil { + if *this.FielL != *that1.FielL { + return false + } + } else if this.FielL != nil { + return false + } else if that1.FielL != nil { + return false + } + if this.FieldM != nil && that1.FieldM != nil { + if *this.FieldM != *that1.FieldM { + return false + } + } else if this.FieldM != nil { + return false + } else if that1.FieldM != nil { + return false + } + if this.FieldN != nil && that1.FieldN != nil { + if *this.FieldN != *that1.FieldN { + return false + } + } else if this.FieldN != nil { + return false + } else if that1.FieldN != nil { + return false + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinRepNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinRepNativebut is not nil && this == nil") + } + if len(this.FieldA) != len(that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", len(this.FieldA), len(that1.FieldA)) + } + for i := range this.FieldA { + if this.FieldA[i] != that1.FieldA[i] { + return fmt.Errorf("FieldA this[%v](%v) Not Equal that[%v](%v)", i, this.FieldA[i], i, that1.FieldA[i]) + } + } + if len(this.FieldB) != len(that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", len(this.FieldB), len(that1.FieldB)) + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return fmt.Errorf("FieldB this[%v](%v) Not Equal that[%v](%v)", i, this.FieldB[i], i, that1.FieldB[i]) + } + } + if len(this.FieldC) != len(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", len(this.FieldC), len(that1.FieldC)) + } + for i := range this.FieldC { + if this.FieldC[i] != that1.FieldC[i] { + return fmt.Errorf("FieldC this[%v](%v) Not Equal that[%v](%v)", i, this.FieldC[i], i, that1.FieldC[i]) + } + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if this.FieldD[i] != that1.FieldD[i] { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if len(this.FieldE) != len(that1.FieldE) { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", len(this.FieldE), len(that1.FieldE)) + } + for i := range this.FieldE { + if this.FieldE[i] != that1.FieldE[i] { + return fmt.Errorf("FieldE this[%v](%v) Not Equal that[%v](%v)", i, this.FieldE[i], i, that1.FieldE[i]) + } + } + if len(this.FieldF) != len(that1.FieldF) { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", len(this.FieldF), len(that1.FieldF)) + } + for i := range this.FieldF { + if this.FieldF[i] != that1.FieldF[i] { + return fmt.Errorf("FieldF this[%v](%v) Not Equal that[%v](%v)", i, this.FieldF[i], i, that1.FieldF[i]) + } + } + if len(this.FieldG) != len(that1.FieldG) { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", len(this.FieldG), len(that1.FieldG)) + } + for i := range this.FieldG { + if this.FieldG[i] != that1.FieldG[i] { + return fmt.Errorf("FieldG this[%v](%v) Not Equal that[%v](%v)", i, this.FieldG[i], i, that1.FieldG[i]) + } + } + if len(this.FieldH) != len(that1.FieldH) { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", len(this.FieldH), len(that1.FieldH)) + } + for i := range this.FieldH { + if this.FieldH[i] != that1.FieldH[i] { + return fmt.Errorf("FieldH this[%v](%v) Not Equal that[%v](%v)", i, this.FieldH[i], i, that1.FieldH[i]) + } + } + if len(this.FieldI) != len(that1.FieldI) { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", len(this.FieldI), len(that1.FieldI)) + } + for i := range this.FieldI { + if this.FieldI[i] != that1.FieldI[i] { + return fmt.Errorf("FieldI this[%v](%v) Not Equal that[%v](%v)", i, this.FieldI[i], i, that1.FieldI[i]) + } + } + if len(this.FieldJ) != len(that1.FieldJ) { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", len(this.FieldJ), len(that1.FieldJ)) + } + for i := range this.FieldJ { + if this.FieldJ[i] != that1.FieldJ[i] { + return fmt.Errorf("FieldJ this[%v](%v) Not Equal that[%v](%v)", i, this.FieldJ[i], i, that1.FieldJ[i]) + } + } + if len(this.FieldK) != len(that1.FieldK) { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", len(this.FieldK), len(that1.FieldK)) + } + for i := range this.FieldK { + if this.FieldK[i] != that1.FieldK[i] { + return fmt.Errorf("FieldK this[%v](%v) Not Equal that[%v](%v)", i, this.FieldK[i], i, that1.FieldK[i]) + } + } + if len(this.FieldL) != len(that1.FieldL) { + return fmt.Errorf("FieldL this(%v) Not Equal that(%v)", len(this.FieldL), len(that1.FieldL)) + } + for i := range this.FieldL { + if this.FieldL[i] != that1.FieldL[i] { + return fmt.Errorf("FieldL this[%v](%v) Not Equal that[%v](%v)", i, this.FieldL[i], i, that1.FieldL[i]) + } + } + if len(this.FieldM) != len(that1.FieldM) { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", len(this.FieldM), len(that1.FieldM)) + } + for i := range this.FieldM { + if this.FieldM[i] != that1.FieldM[i] { + return fmt.Errorf("FieldM this[%v](%v) Not Equal that[%v](%v)", i, this.FieldM[i], i, that1.FieldM[i]) + } + } + if len(this.FieldN) != len(that1.FieldN) { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", len(this.FieldN), len(that1.FieldN)) + } + for i := range this.FieldN { + if this.FieldN[i] != that1.FieldN[i] { + return fmt.Errorf("FieldN this[%v](%v) Not Equal that[%v](%v)", i, this.FieldN[i], i, that1.FieldN[i]) + } + } + if len(this.FieldO) != len(that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", len(this.FieldO), len(that1.FieldO)) + } + for i := range this.FieldO { + if !bytes.Equal(this.FieldO[i], that1.FieldO[i]) { + return fmt.Errorf("FieldO this[%v](%v) Not Equal that[%v](%v)", i, this.FieldO[i], i, that1.FieldO[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.FieldA) != len(that1.FieldA) { + return false + } + for i := range this.FieldA { + if this.FieldA[i] != that1.FieldA[i] { + return false + } + } + if len(this.FieldB) != len(that1.FieldB) { + return false + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return false + } + } + if len(this.FieldC) != len(that1.FieldC) { + return false + } + for i := range this.FieldC { + if this.FieldC[i] != that1.FieldC[i] { + return false + } + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if this.FieldD[i] != that1.FieldD[i] { + return false + } + } + if len(this.FieldE) != len(that1.FieldE) { + return false + } + for i := range this.FieldE { + if this.FieldE[i] != that1.FieldE[i] { + return false + } + } + if len(this.FieldF) != len(that1.FieldF) { + return false + } + for i := range this.FieldF { + if this.FieldF[i] != that1.FieldF[i] { + return false + } + } + if len(this.FieldG) != len(that1.FieldG) { + return false + } + for i := range this.FieldG { + if this.FieldG[i] != that1.FieldG[i] { + return false + } + } + if len(this.FieldH) != len(that1.FieldH) { + return false + } + for i := range this.FieldH { + if this.FieldH[i] != that1.FieldH[i] { + return false + } + } + if len(this.FieldI) != len(that1.FieldI) { + return false + } + for i := range this.FieldI { + if this.FieldI[i] != that1.FieldI[i] { + return false + } + } + if len(this.FieldJ) != len(that1.FieldJ) { + return false + } + for i := range this.FieldJ { + if this.FieldJ[i] != that1.FieldJ[i] { + return false + } + } + if len(this.FieldK) != len(that1.FieldK) { + return false + } + for i := range this.FieldK { + if this.FieldK[i] != that1.FieldK[i] { + return false + } + } + if len(this.FieldL) != len(that1.FieldL) { + return false + } + for i := range this.FieldL { + if this.FieldL[i] != that1.FieldL[i] { + return false + } + } + if len(this.FieldM) != len(that1.FieldM) { + return false + } + for i := range this.FieldM { + if this.FieldM[i] != that1.FieldM[i] { + return false + } + } + if len(this.FieldN) != len(that1.FieldN) { + return false + } + for i := range this.FieldN { + if this.FieldN[i] != that1.FieldN[i] { + return false + } + } + if len(this.FieldO) != len(that1.FieldO) { + return false + } + for i := range this.FieldO { + if !bytes.Equal(this.FieldO[i], that1.FieldO[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinStruct) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinStructbut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if !this.FieldC.Equal(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", *this.FieldE, *that1.FieldE) + } + } else if this.FieldE != nil { + return fmt.Errorf("this.FieldE == nil && that.FieldE != nil") + } else if that1.FieldE != nil { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", *this.FieldF, *that1.FieldF) + } + } else if this.FieldF != nil { + return fmt.Errorf("this.FieldF == nil && that.FieldF != nil") + } else if that1.FieldF != nil { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if !this.FieldG.Equal(that1.FieldG) { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", *this.FieldH, *that1.FieldH) + } + } else if this.FieldH != nil { + return fmt.Errorf("this.FieldH == nil && that.FieldH != nil") + } else if that1.FieldH != nil { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", *this.FieldI, *that1.FieldI) + } + } else if this.FieldI != nil { + return fmt.Errorf("this.FieldI == nil && that.FieldI != nil") + } else if that1.FieldI != nil { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if !bytes.Equal(this.FieldJ, that1.FieldJ) { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if !this.FieldC.Equal(that1.FieldC) { + return false + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return false + } + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return false + } + } else if this.FieldE != nil { + return false + } else if that1.FieldE != nil { + return false + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return false + } + } else if this.FieldF != nil { + return false + } else if that1.FieldF != nil { + return false + } + if !this.FieldG.Equal(that1.FieldG) { + return false + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return false + } + } else if this.FieldH != nil { + return false + } else if that1.FieldH != nil { + return false + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return false + } + } else if this.FieldI != nil { + return false + } else if that1.FieldI != nil { + return false + } + if !bytes.Equal(this.FieldJ, that1.FieldJ) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameCustomType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameCustomType) + if !ok { + return fmt.Errorf("that is not of type *CustomNameCustomType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameCustomType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameCustomTypebut is not nil && this == nil") + } + if that1.FieldA == nil { + if this.FieldA != nil { + return fmt.Errorf("this.FieldA != nil && that1.FieldA == nil") + } + } else if !this.FieldA.Equal(*that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if that1.FieldB == nil { + if this.FieldB != nil { + return fmt.Errorf("this.FieldB != nil && that1.FieldB == nil") + } + } else if !this.FieldB.Equal(*that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if len(this.FieldC) != len(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", len(this.FieldC), len(that1.FieldC)) + } + for i := range this.FieldC { + if !this.FieldC[i].Equal(that1.FieldC[i]) { + return fmt.Errorf("FieldC this[%v](%v) Not Equal that[%v](%v)", i, this.FieldC[i], i, that1.FieldC[i]) + } + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameCustomType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameCustomType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.FieldA == nil { + if this.FieldA != nil { + return false + } + } else if !this.FieldA.Equal(*that1.FieldA) { + return false + } + if that1.FieldB == nil { + if this.FieldB != nil { + return false + } + } else if !this.FieldB.Equal(*that1.FieldB) { + return false + } + if len(this.FieldC) != len(that1.FieldC) { + return false + } + for i := range this.FieldC { + if !this.FieldC[i].Equal(that1.FieldC[i]) { + return false + } + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinEmbeddedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinEmbeddedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinEmbeddedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinEmbeddedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinEmbeddedStructUnionbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.FieldA.Equal(that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinEmbeddedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinEmbeddedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.FieldA.Equal(that1.FieldA) { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameEnum) + if !ok { + return fmt.Errorf("that is not of type *CustomNameEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameEnumbut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if len(this.FieldB) != len(that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", len(this.FieldB), len(that1.FieldB)) + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return fmt.Errorf("FieldB this[%v](%v) Not Equal that[%v](%v)", i, this.FieldB[i], i, that1.FieldB[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if len(this.FieldB) != len(that1.FieldB) { + return false + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NoExtensionsMap) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NoExtensionsMap) + if !ok { + return fmt.Errorf("that is not of type *NoExtensionsMap") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NoExtensionsMap but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NoExtensionsMapbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) { + return fmt.Errorf("XXX_extensions this(%v) Not Equal that(%v)", this.XXX_extensions, that1.XXX_extensions) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NoExtensionsMap) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NoExtensionsMap) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Unrecognized) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Unrecognized) + if !ok { + return fmt.Errorf("that is not of type *Unrecognized") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Unrecognized but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Unrecognizedbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *Unrecognized) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Unrecognized) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} +func (this *UnrecognizedWithInner) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithInner) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithInner") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithInner but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithInnerbut is not nil && this == nil") + } + if len(this.Embedded) != len(that1.Embedded) { + return fmt.Errorf("Embedded this(%v) Not Equal that(%v)", len(this.Embedded), len(that1.Embedded)) + } + for i := range this.Embedded { + if !this.Embedded[i].Equal(that1.Embedded[i]) { + return fmt.Errorf("Embedded this[%v](%v) Not Equal that[%v](%v)", i, this.Embedded[i], i, that1.Embedded[i]) + } + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *UnrecognizedWithInner) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithInner) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Embedded) != len(that1.Embedded) { + return false + } + for i := range this.Embedded { + if !this.Embedded[i].Equal(that1.Embedded[i]) { + return false + } + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *UnrecognizedWithInner_Inner) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithInner_Inner) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithInner_Inner") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithInner_Inner but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithInner_Innerbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *UnrecognizedWithInner_Inner) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithInner_Inner) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} +func (this *UnrecognizedWithEmbed) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithEmbed) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithEmbed") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithEmbed but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithEmbedbut is not nil && this == nil") + } + if !this.UnrecognizedWithEmbed_Embedded.Equal(&that1.UnrecognizedWithEmbed_Embedded) { + return fmt.Errorf("UnrecognizedWithEmbed_Embedded this(%v) Not Equal that(%v)", this.UnrecognizedWithEmbed_Embedded, that1.UnrecognizedWithEmbed_Embedded) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *UnrecognizedWithEmbed) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithEmbed) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.UnrecognizedWithEmbed_Embedded.Equal(&that1.UnrecognizedWithEmbed_Embedded) { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *UnrecognizedWithEmbed_Embedded) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithEmbed_Embedded) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithEmbed_Embedded") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithEmbed_Embedded but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithEmbed_Embeddedbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *UnrecognizedWithEmbed_Embedded) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithEmbed_Embedded) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} + +type NidOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() float64 + GetField2() float32 + GetField3() int32 + GetField4() int64 + GetField5() uint32 + GetField6() uint64 + GetField7() int32 + GetField8() int64 + GetField9() uint32 + GetField10() int32 + GetField11() uint64 + GetField12() int64 + GetField13() bool + GetField14() string + GetField15() []byte +} + +func (this *NidOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptNativeFromFace(this) +} + +func (this *NidOptNative) GetField1() float64 { + return this.Field1 +} + +func (this *NidOptNative) GetField2() float32 { + return this.Field2 +} + +func (this *NidOptNative) GetField3() int32 { + return this.Field3 +} + +func (this *NidOptNative) GetField4() int64 { + return this.Field4 +} + +func (this *NidOptNative) GetField5() uint32 { + return this.Field5 +} + +func (this *NidOptNative) GetField6() uint64 { + return this.Field6 +} + +func (this *NidOptNative) GetField7() int32 { + return this.Field7 +} + +func (this *NidOptNative) GetField8() int64 { + return this.Field8 +} + +func (this *NidOptNative) GetField9() uint32 { + return this.Field9 +} + +func (this *NidOptNative) GetField10() int32 { + return this.Field10 +} + +func (this *NidOptNative) GetField11() uint64 { + return this.Field11 +} + +func (this *NidOptNative) GetField12() int64 { + return this.Field12 +} + +func (this *NidOptNative) GetField13() bool { + return this.Field13 +} + +func (this *NidOptNative) GetField14() string { + return this.Field14 +} + +func (this *NidOptNative) GetField15() []byte { + return this.Field15 +} + +func NewNidOptNativeFromFace(that NidOptNativeFace) *NidOptNative { + this := &NidOptNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *int32 + GetField4() *int64 + GetField5() *uint32 + GetField6() *uint64 + GetField7() *int32 + GetField8() *int64 + GetField9() *uint32 + GetField10() *int32 + GetField11() *uint64 + GetField12() *int64 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptNativeFromFace(this) +} + +func (this *NinOptNative) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptNative) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptNative) GetField3() *int32 { + return this.Field3 +} + +func (this *NinOptNative) GetField4() *int64 { + return this.Field4 +} + +func (this *NinOptNative) GetField5() *uint32 { + return this.Field5 +} + +func (this *NinOptNative) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptNative) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptNative) GetField8() *int64 { + return this.Field8 +} + +func (this *NinOptNative) GetField9() *uint32 { + return this.Field9 +} + +func (this *NinOptNative) GetField10() *int32 { + return this.Field10 +} + +func (this *NinOptNative) GetField11() *uint64 { + return this.Field11 +} + +func (this *NinOptNative) GetField12() *int64 { + return this.Field12 +} + +func (this *NinOptNative) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptNative) GetField14() *string { + return this.Field14 +} + +func (this *NinOptNative) GetField15() []byte { + return this.Field15 +} + +func NewNinOptNativeFromFace(that NinOptNativeFace) *NinOptNative { + this := &NinOptNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NidRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepNativeFromFace(this) +} + +func (this *NidRepNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NidRepNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NidRepNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NidRepNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NidRepNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NidRepNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NidRepNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NidRepNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NidRepNative) GetField13() []bool { + return this.Field13 +} + +func (this *NidRepNative) GetField14() []string { + return this.Field14 +} + +func (this *NidRepNative) GetField15() [][]byte { + return this.Field15 +} + +func NewNidRepNativeFromFace(that NidRepNativeFace) *NidRepNative { + this := &NidRepNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NinRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepNativeFromFace(this) +} + +func (this *NinRepNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NinRepNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NinRepNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NinRepNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NinRepNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NinRepNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NinRepNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NinRepNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NinRepNative) GetField13() []bool { + return this.Field13 +} + +func (this *NinRepNative) GetField14() []string { + return this.Field14 +} + +func (this *NinRepNative) GetField15() [][]byte { + return this.Field15 +} + +func NewNinRepNativeFromFace(that NinRepNativeFace) *NinRepNative { + this := &NinRepNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepPackedNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool +} + +func (this *NidRepPackedNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepPackedNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepPackedNativeFromFace(this) +} + +func (this *NidRepPackedNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepPackedNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepPackedNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NidRepPackedNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NidRepPackedNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NidRepPackedNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepPackedNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepPackedNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NidRepPackedNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NidRepPackedNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NidRepPackedNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NidRepPackedNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NidRepPackedNative) GetField13() []bool { + return this.Field13 +} + +func NewNidRepPackedNativeFromFace(that NidRepPackedNativeFace) *NidRepPackedNative { + this := &NidRepPackedNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + return this +} + +type NinRepPackedNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool +} + +func (this *NinRepPackedNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepPackedNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepPackedNativeFromFace(this) +} + +func (this *NinRepPackedNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepPackedNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepPackedNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NinRepPackedNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NinRepPackedNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NinRepPackedNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepPackedNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepPackedNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NinRepPackedNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NinRepPackedNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NinRepPackedNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NinRepPackedNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NinRepPackedNative) GetField13() []bool { + return this.Field13 +} + +func NewNinRepPackedNativeFromFace(that NinRepPackedNativeFace) *NinRepPackedNative { + this := &NinRepPackedNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + return this +} + +type NidOptStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() float64 + GetField2() float32 + GetField3() NidOptNative + GetField4() NinOptNative + GetField6() uint64 + GetField7() int32 + GetField8() NidOptNative + GetField13() bool + GetField14() string + GetField15() []byte +} + +func (this *NidOptStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptStructFromFace(this) +} + +func (this *NidOptStruct) GetField1() float64 { + return this.Field1 +} + +func (this *NidOptStruct) GetField2() float32 { + return this.Field2 +} + +func (this *NidOptStruct) GetField3() NidOptNative { + return this.Field3 +} + +func (this *NidOptStruct) GetField4() NinOptNative { + return this.Field4 +} + +func (this *NidOptStruct) GetField6() uint64 { + return this.Field6 +} + +func (this *NidOptStruct) GetField7() int32 { + return this.Field7 +} + +func (this *NidOptStruct) GetField8() NidOptNative { + return this.Field8 +} + +func (this *NidOptStruct) GetField13() bool { + return this.Field13 +} + +func (this *NidOptStruct) GetField14() string { + return this.Field14 +} + +func (this *NidOptStruct) GetField15() []byte { + return this.Field15 +} + +func NewNidOptStructFromFace(that NidOptStructFace) *NidOptStruct { + this := &NidOptStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *NidOptNative + GetField4() *NinOptNative + GetField6() *uint64 + GetField7() *int32 + GetField8() *NidOptNative + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptStructFromFace(this) +} + +func (this *NinOptStruct) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptStruct) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptStruct) GetField3() *NidOptNative { + return this.Field3 +} + +func (this *NinOptStruct) GetField4() *NinOptNative { + return this.Field4 +} + +func (this *NinOptStruct) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptStruct) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptStruct) GetField8() *NidOptNative { + return this.Field8 +} + +func (this *NinOptStruct) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptStruct) GetField14() *string { + return this.Field14 +} + +func (this *NinOptStruct) GetField15() []byte { + return this.Field15 +} + +func NewNinOptStructFromFace(that NinOptStructFace) *NinOptStruct { + this := &NinOptStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []NidOptNative + GetField4() []NinOptNative + GetField6() []uint64 + GetField7() []int32 + GetField8() []NidOptNative + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NidRepStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepStructFromFace(this) +} + +func (this *NidRepStruct) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepStruct) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepStruct) GetField3() []NidOptNative { + return this.Field3 +} + +func (this *NidRepStruct) GetField4() []NinOptNative { + return this.Field4 +} + +func (this *NidRepStruct) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepStruct) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepStruct) GetField8() []NidOptNative { + return this.Field8 +} + +func (this *NidRepStruct) GetField13() []bool { + return this.Field13 +} + +func (this *NidRepStruct) GetField14() []string { + return this.Field14 +} + +func (this *NidRepStruct) GetField15() [][]byte { + return this.Field15 +} + +func NewNidRepStructFromFace(that NidRepStructFace) *NidRepStruct { + this := &NidRepStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinRepStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []*NidOptNative + GetField4() []*NinOptNative + GetField6() []uint64 + GetField7() []int32 + GetField8() []*NidOptNative + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NinRepStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepStructFromFace(this) +} + +func (this *NinRepStruct) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepStruct) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepStruct) GetField3() []*NidOptNative { + return this.Field3 +} + +func (this *NinRepStruct) GetField4() []*NinOptNative { + return this.Field4 +} + +func (this *NinRepStruct) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepStruct) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepStruct) GetField8() []*NidOptNative { + return this.Field8 +} + +func (this *NinRepStruct) GetField13() []bool { + return this.Field13 +} + +func (this *NinRepStruct) GetField14() []string { + return this.Field14 +} + +func (this *NinRepStruct) GetField15() [][]byte { + return this.Field15 +} + +func NewNinRepStructFromFace(that NinRepStructFace) *NinRepStruct { + this := &NinRepStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidEmbeddedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() NidOptNative + GetField210() bool +} + +func (this *NidEmbeddedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidEmbeddedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidEmbeddedStructFromFace(this) +} + +func (this *NidEmbeddedStruct) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NidEmbeddedStruct) GetField200() NidOptNative { + return this.Field200 +} + +func (this *NidEmbeddedStruct) GetField210() bool { + return this.Field210 +} + +func NewNidEmbeddedStructFromFace(that NidEmbeddedStructFace) *NidEmbeddedStruct { + this := &NidEmbeddedStruct{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NinEmbeddedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() *NidOptNative + GetField210() *bool +} + +func (this *NinEmbeddedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinEmbeddedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinEmbeddedStructFromFace(this) +} + +func (this *NinEmbeddedStruct) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NinEmbeddedStruct) GetField200() *NidOptNative { + return this.Field200 +} + +func (this *NinEmbeddedStruct) GetField210() *bool { + return this.Field210 +} + +func NewNinEmbeddedStructFromFace(that NinEmbeddedStructFace) *NinEmbeddedStruct { + this := &NinEmbeddedStruct{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NidNestedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() NidOptStruct + GetField2() []NidRepStruct +} + +func (this *NidNestedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidNestedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidNestedStructFromFace(this) +} + +func (this *NidNestedStruct) GetField1() NidOptStruct { + return this.Field1 +} + +func (this *NidNestedStruct) GetField2() []NidRepStruct { + return this.Field2 +} + +func NewNidNestedStructFromFace(that NidNestedStructFace) *NidNestedStruct { + this := &NidNestedStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + return this +} + +type NinNestedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *NinOptStruct + GetField2() []*NinRepStruct +} + +func (this *NinNestedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinNestedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinNestedStructFromFace(this) +} + +func (this *NinNestedStruct) GetField1() *NinOptStruct { + return this.Field1 +} + +func (this *NinNestedStruct) GetField2() []*NinRepStruct { + return this.Field2 +} + +func NewNinNestedStructFromFace(that NinNestedStructFace) *NinNestedStruct { + this := &NinNestedStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + return this +} + +type NidOptCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() Uuid + GetValue() github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NidOptCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptCustomFromFace(this) +} + +func (this *NidOptCustom) GetId() Uuid { + return this.Id +} + +func (this *NidOptCustom) GetValue() github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNidOptCustomFromFace(that NidOptCustomFace) *NidOptCustom { + this := &NidOptCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type CustomDashFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetValue() *github_com_gogo_protobuf_test_custom_dash_type.Bytes +} + +func (this *CustomDash) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomDash) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomDashFromFace(this) +} + +func (this *CustomDash) GetValue() *github_com_gogo_protobuf_test_custom_dash_type.Bytes { + return this.Value +} + +func NewCustomDashFromFace(that CustomDashFace) *CustomDash { + this := &CustomDash{} + this.Value = that.GetValue() + return this +} + +type NinOptCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() *Uuid + GetValue() *github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NinOptCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptCustomFromFace(this) +} + +func (this *NinOptCustom) GetId() *Uuid { + return this.Id +} + +func (this *NinOptCustom) GetValue() *github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNinOptCustomFromFace(that NinOptCustomFace) *NinOptCustom { + this := &NinOptCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NidRepCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() []Uuid + GetValue() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NidRepCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepCustomFromFace(this) +} + +func (this *NidRepCustom) GetId() []Uuid { + return this.Id +} + +func (this *NidRepCustom) GetValue() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNidRepCustomFromFace(that NidRepCustomFace) *NidRepCustom { + this := &NidRepCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NinRepCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() []Uuid + GetValue() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NinRepCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepCustomFromFace(this) +} + +func (this *NinRepCustom) GetId() []Uuid { + return this.Id +} + +func (this *NinRepCustom) GetValue() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNinRepCustomFromFace(that NinRepCustomFace) *NinRepCustom { + this := &NinRepCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NinOptNativeUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *int32 + GetField4() *int64 + GetField5() *uint32 + GetField6() *uint64 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptNativeUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptNativeUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptNativeUnionFromFace(this) +} + +func (this *NinOptNativeUnion) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptNativeUnion) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptNativeUnion) GetField3() *int32 { + return this.Field3 +} + +func (this *NinOptNativeUnion) GetField4() *int64 { + return this.Field4 +} + +func (this *NinOptNativeUnion) GetField5() *uint32 { + return this.Field5 +} + +func (this *NinOptNativeUnion) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptNativeUnion) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptNativeUnion) GetField14() *string { + return this.Field14 +} + +func (this *NinOptNativeUnion) GetField15() []byte { + return this.Field15 +} + +func NewNinOptNativeUnionFromFace(that NinOptNativeUnionFace) *NinOptNativeUnion { + this := &NinOptNativeUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *NidOptNative + GetField4() *NinOptNative + GetField6() *uint64 + GetField7() *int32 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptStructUnionFromFace(this) +} + +func (this *NinOptStructUnion) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptStructUnion) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptStructUnion) GetField3() *NidOptNative { + return this.Field3 +} + +func (this *NinOptStructUnion) GetField4() *NinOptNative { + return this.Field4 +} + +func (this *NinOptStructUnion) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptStructUnion) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptStructUnion) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptStructUnion) GetField14() *string { + return this.Field14 +} + +func (this *NinOptStructUnion) GetField15() []byte { + return this.Field15 +} + +func NewNinOptStructUnionFromFace(that NinOptStructUnionFace) *NinOptStructUnion { + this := &NinOptStructUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinEmbeddedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() *NinOptNative + GetField210() *bool +} + +func (this *NinEmbeddedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinEmbeddedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinEmbeddedStructUnionFromFace(this) +} + +func (this *NinEmbeddedStructUnion) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NinEmbeddedStructUnion) GetField200() *NinOptNative { + return this.Field200 +} + +func (this *NinEmbeddedStructUnion) GetField210() *bool { + return this.Field210 +} + +func NewNinEmbeddedStructUnionFromFace(that NinEmbeddedStructUnionFace) *NinEmbeddedStructUnion { + this := &NinEmbeddedStructUnion{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NinNestedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *NinOptNativeUnion + GetField2() *NinOptStructUnion + GetField3() *NinEmbeddedStructUnion +} + +func (this *NinNestedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinNestedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinNestedStructUnionFromFace(this) +} + +func (this *NinNestedStructUnion) GetField1() *NinOptNativeUnion { + return this.Field1 +} + +func (this *NinNestedStructUnion) GetField2() *NinOptStructUnion { + return this.Field2 +} + +func (this *NinNestedStructUnion) GetField3() *NinEmbeddedStructUnion { + return this.Field3 +} + +func NewNinNestedStructUnionFromFace(that NinNestedStructUnionFace) *NinNestedStructUnion { + this := &NinNestedStructUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + return this +} + +type TreeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetOr() *OrBranch + GetAnd() *AndBranch + GetLeaf() *Leaf +} + +func (this *Tree) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Tree) TestProto() github_com_gogo_protobuf_proto.Message { + return NewTreeFromFace(this) +} + +func (this *Tree) GetOr() *OrBranch { + return this.Or +} + +func (this *Tree) GetAnd() *AndBranch { + return this.And +} + +func (this *Tree) GetLeaf() *Leaf { + return this.Leaf +} + +func NewTreeFromFace(that TreeFace) *Tree { + this := &Tree{} + this.Or = that.GetOr() + this.And = that.GetAnd() + this.Leaf = that.GetLeaf() + return this +} + +type OrBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() Tree + GetRight() Tree +} + +func (this *OrBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *OrBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewOrBranchFromFace(this) +} + +func (this *OrBranch) GetLeft() Tree { + return this.Left +} + +func (this *OrBranch) GetRight() Tree { + return this.Right +} + +func NewOrBranchFromFace(that OrBranchFace) *OrBranch { + this := &OrBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type AndBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() Tree + GetRight() Tree +} + +func (this *AndBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AndBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAndBranchFromFace(this) +} + +func (this *AndBranch) GetLeft() Tree { + return this.Left +} + +func (this *AndBranch) GetRight() Tree { + return this.Right +} + +func NewAndBranchFromFace(that AndBranchFace) *AndBranch { + this := &AndBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type LeafFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetValue() int64 + GetStrValue() string +} + +func (this *Leaf) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Leaf) TestProto() github_com_gogo_protobuf_proto.Message { + return NewLeafFromFace(this) +} + +func (this *Leaf) GetValue() int64 { + return this.Value +} + +func (this *Leaf) GetStrValue() string { + return this.StrValue +} + +func NewLeafFromFace(that LeafFace) *Leaf { + this := &Leaf{} + this.Value = that.GetValue() + this.StrValue = that.GetStrValue() + return this +} + +type DeepTreeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetDown() *ADeepBranch + GetAnd() *AndDeepBranch + GetLeaf() *DeepLeaf +} + +func (this *DeepTree) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *DeepTree) TestProto() github_com_gogo_protobuf_proto.Message { + return NewDeepTreeFromFace(this) +} + +func (this *DeepTree) GetDown() *ADeepBranch { + return this.Down +} + +func (this *DeepTree) GetAnd() *AndDeepBranch { + return this.And +} + +func (this *DeepTree) GetLeaf() *DeepLeaf { + return this.Leaf +} + +func NewDeepTreeFromFace(that DeepTreeFace) *DeepTree { + this := &DeepTree{} + this.Down = that.GetDown() + this.And = that.GetAnd() + this.Leaf = that.GetLeaf() + return this +} + +type ADeepBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetDown() DeepTree +} + +func (this *ADeepBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *ADeepBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewADeepBranchFromFace(this) +} + +func (this *ADeepBranch) GetDown() DeepTree { + return this.Down +} + +func NewADeepBranchFromFace(that ADeepBranchFace) *ADeepBranch { + this := &ADeepBranch{} + this.Down = that.GetDown() + return this +} + +type AndDeepBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() DeepTree + GetRight() DeepTree +} + +func (this *AndDeepBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AndDeepBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAndDeepBranchFromFace(this) +} + +func (this *AndDeepBranch) GetLeft() DeepTree { + return this.Left +} + +func (this *AndDeepBranch) GetRight() DeepTree { + return this.Right +} + +func NewAndDeepBranchFromFace(that AndDeepBranchFace) *AndDeepBranch { + this := &AndDeepBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type DeepLeafFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetTree() Tree +} + +func (this *DeepLeaf) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *DeepLeaf) TestProto() github_com_gogo_protobuf_proto.Message { + return NewDeepLeafFromFace(this) +} + +func (this *DeepLeaf) GetTree() Tree { + return this.Tree +} + +func NewDeepLeafFromFace(that DeepLeafFace) *DeepLeaf { + this := &DeepLeaf{} + this.Tree = that.GetTree() + return this +} + +type NilFace interface { + Proto() github_com_gogo_protobuf_proto.Message +} + +func (this *Nil) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Nil) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNilFromFace(this) +} + +func NewNilFromFace(that NilFace) *Nil { + this := &Nil{} + return this +} + +type NidOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() TheTestEnum +} + +func (this *NidOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptEnumFromFace(this) +} + +func (this *NidOptEnum) GetField1() TheTestEnum { + return this.Field1 +} + +func NewNidOptEnumFromFace(that NidOptEnumFace) *NidOptEnum { + this := &NidOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type NinOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *TheTestEnum +} + +func (this *NinOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptEnumFromFace(this) +} + +func (this *NinOptEnum) GetField1() *TheTestEnum { + return this.Field1 +} + +func NewNinOptEnumFromFace(that NinOptEnumFace) *NinOptEnum { + this := &NinOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type NidRepEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []TheTestEnum +} + +func (this *NidRepEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepEnumFromFace(this) +} + +func (this *NidRepEnum) GetField1() []TheTestEnum { + return this.Field1 +} + +func NewNidRepEnumFromFace(that NidRepEnumFace) *NidRepEnum { + this := &NidRepEnum{} + this.Field1 = that.GetField1() + return this +} + +type NinRepEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []TheTestEnum +} + +func (this *NinRepEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepEnumFromFace(this) +} + +func (this *NinRepEnum) GetField1() []TheTestEnum { + return this.Field1 +} + +func NewNinRepEnumFromFace(that NinRepEnumFace) *NinRepEnum { + this := &NinRepEnum{} + this.Field1 = that.GetField1() + return this +} + +type AnotherNinOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *AnotherTestEnum +} + +func (this *AnotherNinOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AnotherNinOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAnotherNinOptEnumFromFace(this) +} + +func (this *AnotherNinOptEnum) GetField1() *AnotherTestEnum { + return this.Field1 +} + +func NewAnotherNinOptEnumFromFace(that AnotherNinOptEnumFace) *AnotherNinOptEnum { + this := &AnotherNinOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type TimerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetTime1() int64 + GetTime2() int64 + GetData() []byte +} + +func (this *Timer) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Timer) TestProto() github_com_gogo_protobuf_proto.Message { + return NewTimerFromFace(this) +} + +func (this *Timer) GetTime1() int64 { + return this.Time1 +} + +func (this *Timer) GetTime2() int64 { + return this.Time2 +} + +func (this *Timer) GetData() []byte { + return this.Data +} + +func NewTimerFromFace(that TimerFace) *Timer { + this := &Timer{} + this.Time1 = that.GetTime1() + this.Time2 = that.GetTime2() + this.Data = that.GetData() + return this +} + +type NestedDefinitionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *int64 + GetEnumField() *NestedDefinition_NestedEnum + GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg + GetNM() *NestedDefinition_NestedMessage +} + +func (this *NestedDefinition) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinitionFromFace(this) +} + +func (this *NestedDefinition) GetField1() *int64 { + return this.Field1 +} + +func (this *NestedDefinition) GetEnumField() *NestedDefinition_NestedEnum { + return this.EnumField +} + +func (this *NestedDefinition) GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.NNM +} + +func (this *NestedDefinition) GetNM() *NestedDefinition_NestedMessage { + return this.NM +} + +func NewNestedDefinitionFromFace(that NestedDefinitionFace) *NestedDefinition { + this := &NestedDefinition{} + this.Field1 = that.GetField1() + this.EnumField = that.GetEnumField() + this.NNM = that.GetNNM() + this.NM = that.GetNM() + return this +} + +type NestedDefinition_NestedMessageFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNestedField1() *uint64 + GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg +} + +func (this *NestedDefinition_NestedMessage) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition_NestedMessage) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinition_NestedMessageFromFace(this) +} + +func (this *NestedDefinition_NestedMessage) GetNestedField1() *uint64 { + return this.NestedField1 +} + +func (this *NestedDefinition_NestedMessage) GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.NNM +} + +func NewNestedDefinition_NestedMessageFromFace(that NestedDefinition_NestedMessageFace) *NestedDefinition_NestedMessage { + this := &NestedDefinition_NestedMessage{} + this.NestedField1 = that.GetNestedField1() + this.NNM = that.GetNNM() + return this +} + +type NestedDefinition_NestedMessage_NestedNestedMsgFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNestedNestedField1() *string +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinition_NestedMessage_NestedNestedMsgFromFace(this) +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) GetNestedNestedField1() *string { + return this.NestedNestedField1 +} + +func NewNestedDefinition_NestedMessage_NestedNestedMsgFromFace(that NestedDefinition_NestedMessage_NestedNestedMsgFace) *NestedDefinition_NestedMessage_NestedNestedMsg { + this := &NestedDefinition_NestedMessage_NestedNestedMsg{} + this.NestedNestedField1 = that.GetNestedNestedField1() + return this +} + +type NestedScopeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetA() *NestedDefinition_NestedMessage_NestedNestedMsg + GetB() *NestedDefinition_NestedEnum + GetC() *NestedDefinition_NestedMessage +} + +func (this *NestedScope) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedScope) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedScopeFromFace(this) +} + +func (this *NestedScope) GetA() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.A +} + +func (this *NestedScope) GetB() *NestedDefinition_NestedEnum { + return this.B +} + +func (this *NestedScope) GetC() *NestedDefinition_NestedMessage { + return this.C +} + +func NewNestedScopeFromFace(that NestedScopeFace) *NestedScope { + this := &NestedScope{} + this.A = that.GetA() + this.B = that.GetB() + this.C = that.GetC() + return this +} + +type CustomContainerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetCustomStruct() NidOptCustom +} + +func (this *CustomContainer) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomContainer) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomContainerFromFace(this) +} + +func (this *CustomContainer) GetCustomStruct() NidOptCustom { + return this.CustomStruct +} + +func NewCustomContainerFromFace(that CustomContainerFace) *CustomContainer { + this := &CustomContainer{} + this.CustomStruct = that.GetCustomStruct() + return this +} + +type CustomNameNidOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() float64 + GetFieldB() float32 + GetFieldC() int32 + GetFieldD() int64 + GetFieldE() uint32 + GetFieldF() uint64 + GetFieldG() int32 + GetFieldH() int64 + GetFieldI() uint32 + GetFieldJ() int32 + GetFieldK() uint64 + GetFieldL() int64 + GetFieldM() bool + GetFieldN() string + GetFieldO() []byte +} + +func (this *CustomNameNidOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNidOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNidOptNativeFromFace(this) +} + +func (this *CustomNameNidOptNative) GetFieldA() float64 { + return this.FieldA +} + +func (this *CustomNameNidOptNative) GetFieldB() float32 { + return this.FieldB +} + +func (this *CustomNameNidOptNative) GetFieldC() int32 { + return this.FieldC +} + +func (this *CustomNameNidOptNative) GetFieldD() int64 { + return this.FieldD +} + +func (this *CustomNameNidOptNative) GetFieldE() uint32 { + return this.FieldE +} + +func (this *CustomNameNidOptNative) GetFieldF() uint64 { + return this.FieldF +} + +func (this *CustomNameNidOptNative) GetFieldG() int32 { + return this.FieldG +} + +func (this *CustomNameNidOptNative) GetFieldH() int64 { + return this.FieldH +} + +func (this *CustomNameNidOptNative) GetFieldI() uint32 { + return this.FieldI +} + +func (this *CustomNameNidOptNative) GetFieldJ() int32 { + return this.FieldJ +} + +func (this *CustomNameNidOptNative) GetFieldK() uint64 { + return this.FieldK +} + +func (this *CustomNameNidOptNative) GetFieldL() int64 { + return this.FieldL +} + +func (this *CustomNameNidOptNative) GetFieldM() bool { + return this.FieldM +} + +func (this *CustomNameNidOptNative) GetFieldN() string { + return this.FieldN +} + +func (this *CustomNameNidOptNative) GetFieldO() []byte { + return this.FieldO +} + +func NewCustomNameNidOptNativeFromFace(that CustomNameNidOptNativeFace) *CustomNameNidOptNative { + this := &CustomNameNidOptNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FieldL = that.GetFieldL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *float64 + GetFieldB() *float32 + GetFieldC() *int32 + GetFieldD() *int64 + GetFieldE() *uint32 + GetFieldF() *uint64 + GetFieldG() *int32 + GetFieldH() *int64 + GetFieldI() *uint32 + GetFieldJ() *int32 + GetFieldK() *uint64 + GetFielL() *int64 + GetFieldM() *bool + GetFieldN() *string + GetFieldO() []byte +} + +func (this *CustomNameNinOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinOptNativeFromFace(this) +} + +func (this *CustomNameNinOptNative) GetFieldA() *float64 { + return this.FieldA +} + +func (this *CustomNameNinOptNative) GetFieldB() *float32 { + return this.FieldB +} + +func (this *CustomNameNinOptNative) GetFieldC() *int32 { + return this.FieldC +} + +func (this *CustomNameNinOptNative) GetFieldD() *int64 { + return this.FieldD +} + +func (this *CustomNameNinOptNative) GetFieldE() *uint32 { + return this.FieldE +} + +func (this *CustomNameNinOptNative) GetFieldF() *uint64 { + return this.FieldF +} + +func (this *CustomNameNinOptNative) GetFieldG() *int32 { + return this.FieldG +} + +func (this *CustomNameNinOptNative) GetFieldH() *int64 { + return this.FieldH +} + +func (this *CustomNameNinOptNative) GetFieldI() *uint32 { + return this.FieldI +} + +func (this *CustomNameNinOptNative) GetFieldJ() *int32 { + return this.FieldJ +} + +func (this *CustomNameNinOptNative) GetFieldK() *uint64 { + return this.FieldK +} + +func (this *CustomNameNinOptNative) GetFielL() *int64 { + return this.FielL +} + +func (this *CustomNameNinOptNative) GetFieldM() *bool { + return this.FieldM +} + +func (this *CustomNameNinOptNative) GetFieldN() *string { + return this.FieldN +} + +func (this *CustomNameNinOptNative) GetFieldO() []byte { + return this.FieldO +} + +func NewCustomNameNinOptNativeFromFace(that CustomNameNinOptNativeFace) *CustomNameNinOptNative { + this := &CustomNameNinOptNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FielL = that.GetFielL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() []float64 + GetFieldB() []float32 + GetFieldC() []int32 + GetFieldD() []int64 + GetFieldE() []uint32 + GetFieldF() []uint64 + GetFieldG() []int32 + GetFieldH() []int64 + GetFieldI() []uint32 + GetFieldJ() []int32 + GetFieldK() []uint64 + GetFieldL() []int64 + GetFieldM() []bool + GetFieldN() []string + GetFieldO() [][]byte +} + +func (this *CustomNameNinRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinRepNativeFromFace(this) +} + +func (this *CustomNameNinRepNative) GetFieldA() []float64 { + return this.FieldA +} + +func (this *CustomNameNinRepNative) GetFieldB() []float32 { + return this.FieldB +} + +func (this *CustomNameNinRepNative) GetFieldC() []int32 { + return this.FieldC +} + +func (this *CustomNameNinRepNative) GetFieldD() []int64 { + return this.FieldD +} + +func (this *CustomNameNinRepNative) GetFieldE() []uint32 { + return this.FieldE +} + +func (this *CustomNameNinRepNative) GetFieldF() []uint64 { + return this.FieldF +} + +func (this *CustomNameNinRepNative) GetFieldG() []int32 { + return this.FieldG +} + +func (this *CustomNameNinRepNative) GetFieldH() []int64 { + return this.FieldH +} + +func (this *CustomNameNinRepNative) GetFieldI() []uint32 { + return this.FieldI +} + +func (this *CustomNameNinRepNative) GetFieldJ() []int32 { + return this.FieldJ +} + +func (this *CustomNameNinRepNative) GetFieldK() []uint64 { + return this.FieldK +} + +func (this *CustomNameNinRepNative) GetFieldL() []int64 { + return this.FieldL +} + +func (this *CustomNameNinRepNative) GetFieldM() []bool { + return this.FieldM +} + +func (this *CustomNameNinRepNative) GetFieldN() []string { + return this.FieldN +} + +func (this *CustomNameNinRepNative) GetFieldO() [][]byte { + return this.FieldO +} + +func NewCustomNameNinRepNativeFromFace(that CustomNameNinRepNativeFace) *CustomNameNinRepNative { + this := &CustomNameNinRepNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FieldL = that.GetFieldL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *float64 + GetFieldB() *float32 + GetFieldC() *NidOptNative + GetFieldD() []*NinOptNative + GetFieldE() *uint64 + GetFieldF() *int32 + GetFieldG() *NidOptNative + GetFieldH() *bool + GetFieldI() *string + GetFieldJ() []byte +} + +func (this *CustomNameNinStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinStructFromFace(this) +} + +func (this *CustomNameNinStruct) GetFieldA() *float64 { + return this.FieldA +} + +func (this *CustomNameNinStruct) GetFieldB() *float32 { + return this.FieldB +} + +func (this *CustomNameNinStruct) GetFieldC() *NidOptNative { + return this.FieldC +} + +func (this *CustomNameNinStruct) GetFieldD() []*NinOptNative { + return this.FieldD +} + +func (this *CustomNameNinStruct) GetFieldE() *uint64 { + return this.FieldE +} + +func (this *CustomNameNinStruct) GetFieldF() *int32 { + return this.FieldF +} + +func (this *CustomNameNinStruct) GetFieldG() *NidOptNative { + return this.FieldG +} + +func (this *CustomNameNinStruct) GetFieldH() *bool { + return this.FieldH +} + +func (this *CustomNameNinStruct) GetFieldI() *string { + return this.FieldI +} + +func (this *CustomNameNinStruct) GetFieldJ() []byte { + return this.FieldJ +} + +func NewCustomNameNinStructFromFace(that CustomNameNinStructFace) *CustomNameNinStruct { + this := &CustomNameNinStruct{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + return this +} + +type CustomNameCustomTypeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *Uuid + GetFieldB() *github_com_gogo_protobuf_test_custom.Uint128 + GetFieldC() []Uuid + GetFieldD() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *CustomNameCustomType) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameCustomType) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameCustomTypeFromFace(this) +} + +func (this *CustomNameCustomType) GetFieldA() *Uuid { + return this.FieldA +} + +func (this *CustomNameCustomType) GetFieldB() *github_com_gogo_protobuf_test_custom.Uint128 { + return this.FieldB +} + +func (this *CustomNameCustomType) GetFieldC() []Uuid { + return this.FieldC +} + +func (this *CustomNameCustomType) GetFieldD() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.FieldD +} + +func NewCustomNameCustomTypeFromFace(that CustomNameCustomTypeFace) *CustomNameCustomType { + this := &CustomNameCustomType{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + return this +} + +type CustomNameNinEmbeddedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetFieldA() *NinOptNative + GetFieldB() *bool +} + +func (this *CustomNameNinEmbeddedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinEmbeddedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinEmbeddedStructUnionFromFace(this) +} + +func (this *CustomNameNinEmbeddedStructUnion) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *CustomNameNinEmbeddedStructUnion) GetFieldA() *NinOptNative { + return this.FieldA +} + +func (this *CustomNameNinEmbeddedStructUnion) GetFieldB() *bool { + return this.FieldB +} + +func NewCustomNameNinEmbeddedStructUnionFromFace(that CustomNameNinEmbeddedStructUnionFace) *CustomNameNinEmbeddedStructUnion { + this := &CustomNameNinEmbeddedStructUnion{} + this.NidOptNative = that.GetNidOptNative() + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + return this +} + +type CustomNameEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *TheTestEnum + GetFieldB() []TheTestEnum +} + +func (this *CustomNameEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameEnumFromFace(this) +} + +func (this *CustomNameEnum) GetFieldA() *TheTestEnum { + return this.FieldA +} + +func (this *CustomNameEnum) GetFieldB() []TheTestEnum { + return this.FieldB +} + +func NewCustomNameEnumFromFace(that CustomNameEnumFace) *CustomNameEnum { + this := &CustomNameEnum{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + return this +} + +type UnrecognizedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *string +} + +func (this *Unrecognized) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Unrecognized) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedFromFace(this) +} + +func (this *Unrecognized) GetField1() *string { + return this.Field1 +} + +func NewUnrecognizedFromFace(that UnrecognizedFace) *Unrecognized { + this := &Unrecognized{} + this.Field1 = that.GetField1() + return this +} + +type UnrecognizedWithInnerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetEmbedded() []*UnrecognizedWithInner_Inner + GetField2() *string +} + +func (this *UnrecognizedWithInner) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithInner) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithInnerFromFace(this) +} + +func (this *UnrecognizedWithInner) GetEmbedded() []*UnrecognizedWithInner_Inner { + return this.Embedded +} + +func (this *UnrecognizedWithInner) GetField2() *string { + return this.Field2 +} + +func NewUnrecognizedWithInnerFromFace(that UnrecognizedWithInnerFace) *UnrecognizedWithInner { + this := &UnrecognizedWithInner{} + this.Embedded = that.GetEmbedded() + this.Field2 = that.GetField2() + return this +} + +type UnrecognizedWithInner_InnerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *uint32 +} + +func (this *UnrecognizedWithInner_Inner) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithInner_Inner) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithInner_InnerFromFace(this) +} + +func (this *UnrecognizedWithInner_Inner) GetField1() *uint32 { + return this.Field1 +} + +func NewUnrecognizedWithInner_InnerFromFace(that UnrecognizedWithInner_InnerFace) *UnrecognizedWithInner_Inner { + this := &UnrecognizedWithInner_Inner{} + this.Field1 = that.GetField1() + return this +} + +type UnrecognizedWithEmbedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetUnrecognizedWithEmbed_Embedded() UnrecognizedWithEmbed_Embedded + GetField2() *string +} + +func (this *UnrecognizedWithEmbed) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithEmbed) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithEmbedFromFace(this) +} + +func (this *UnrecognizedWithEmbed) GetUnrecognizedWithEmbed_Embedded() UnrecognizedWithEmbed_Embedded { + return this.UnrecognizedWithEmbed_Embedded +} + +func (this *UnrecognizedWithEmbed) GetField2() *string { + return this.Field2 +} + +func NewUnrecognizedWithEmbedFromFace(that UnrecognizedWithEmbedFace) *UnrecognizedWithEmbed { + this := &UnrecognizedWithEmbed{} + this.UnrecognizedWithEmbed_Embedded = that.GetUnrecognizedWithEmbed_Embedded() + this.Field2 = that.GetField2() + return this +} + +type UnrecognizedWithEmbed_EmbeddedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *uint32 +} + +func (this *UnrecognizedWithEmbed_Embedded) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithEmbed_Embedded) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithEmbed_EmbeddedFromFace(this) +} + +func (this *UnrecognizedWithEmbed_Embedded) GetField1() *uint32 { + return this.Field1 +} + +func NewUnrecognizedWithEmbed_EmbeddedFromFace(that UnrecognizedWithEmbed_EmbeddedFace) *UnrecognizedWithEmbed_Embedded { + this := &UnrecognizedWithEmbed_Embedded{} + this.Field1 = that.GetField1() + return this +} + +func (this *NidOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NidOptNative{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinOptNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+valueToGoStringThetest(this.Field8, "int64")+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+valueToGoStringThetest(this.Field9, "uint32")+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+valueToGoStringThetest(this.Field10, "int32")+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+valueToGoStringThetest(this.Field11, "uint64")+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+valueToGoStringThetest(this.Field12, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NidRepNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinRepNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepPackedNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 17) + s = append(s, "&test.NidRepPackedNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepPackedNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 17) + s = append(s, "&test.NinRepPackedNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NidOptStruct{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + s = append(s, "Field3: "+strings.Replace(this.Field3.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field4: "+strings.Replace(this.Field4.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + s = append(s, "Field8: "+strings.Replace(this.Field8.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NinOptStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NidRepStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+strings.Replace(fmt.Sprintf("%#v", this.Field3), `&`, ``, 1)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+strings.Replace(fmt.Sprintf("%#v", this.Field4), `&`, ``, 1)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+strings.Replace(fmt.Sprintf("%#v", this.Field8), `&`, ``, 1)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NinRepStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidEmbeddedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NidEmbeddedStruct{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + s = append(s, "Field200: "+strings.Replace(this.Field200.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field210: "+fmt.Sprintf("%#v", this.Field210)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinEmbeddedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinEmbeddedStruct{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.Field200 != nil { + s = append(s, "Field200: "+fmt.Sprintf("%#v", this.Field200)+",\n") + } + if this.Field210 != nil { + s = append(s, "Field210: "+valueToGoStringThetest(this.Field210, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidNestedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidNestedStruct{") + s = append(s, "Field1: "+strings.Replace(this.Field1.GoString(), `&`, ``, 1)+",\n") + if this.Field2 != nil { + s = append(s, "Field2: "+strings.Replace(fmt.Sprintf("%#v", this.Field2), `&`, ``, 1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinNestedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinNestedStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidOptCustom{") + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomDash) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.CustomDash{") + if this.Value != nil { + s = append(s, "Value: "+valueToGoStringThetest(this.Value, "github_com_gogo_protobuf_test_custom_dash_type.Bytes")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinOptCustom{") + if this.Id != nil { + s = append(s, "Id: "+valueToGoStringThetest(this.Id, "Uuid")+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+valueToGoStringThetest(this.Value, "github_com_gogo_protobuf_test_custom.Uint128")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidRepCustom{") + if this.Id != nil { + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinRepCustom{") + if this.Id != nil { + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNativeUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 13) + s = append(s, "&test.NinOptNativeUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 13) + s = append(s, "&test.NinOptStructUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinEmbeddedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinEmbeddedStructUnion{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.Field200 != nil { + s = append(s, "Field200: "+fmt.Sprintf("%#v", this.Field200)+",\n") + } + if this.Field210 != nil { + s = append(s, "Field210: "+valueToGoStringThetest(this.Field210, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinNestedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinNestedStructUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Tree) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.Tree{") + if this.Or != nil { + s = append(s, "Or: "+fmt.Sprintf("%#v", this.Or)+",\n") + } + if this.And != nil { + s = append(s, "And: "+fmt.Sprintf("%#v", this.And)+",\n") + } + if this.Leaf != nil { + s = append(s, "Leaf: "+fmt.Sprintf("%#v", this.Leaf)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OrBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.OrBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AndBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.AndBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Leaf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.Leaf{") + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + s = append(s, "StrValue: "+fmt.Sprintf("%#v", this.StrValue)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DeepTree) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.DeepTree{") + if this.Down != nil { + s = append(s, "Down: "+fmt.Sprintf("%#v", this.Down)+",\n") + } + if this.And != nil { + s = append(s, "And: "+fmt.Sprintf("%#v", this.And)+",\n") + } + if this.Leaf != nil { + s = append(s, "Leaf: "+fmt.Sprintf("%#v", this.Leaf)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *ADeepBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.ADeepBranch{") + s = append(s, "Down: "+strings.Replace(this.Down.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AndDeepBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.AndDeepBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DeepLeaf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.DeepLeaf{") + s = append(s, "Tree: "+strings.Replace(this.Tree.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Nil) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 4) + s = append(s, "&test.Nil{") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NidOptEnum{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinOptEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.TheTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NidRepEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinRepEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptEnumDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinOptEnumDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.TheTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AnotherNinOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.AnotherNinOptEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.AnotherTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AnotherNinOptEnumDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.AnotherNinOptEnumDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.AnotherTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Timer) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.Timer{") + s = append(s, "Time1: "+fmt.Sprintf("%#v", this.Time1)+",\n") + s = append(s, "Time2: "+fmt.Sprintf("%#v", this.Time2)+",\n") + s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MyExtendable) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.MyExtendable{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringThetest(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OtherExtenable) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.OtherExtenable{") + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "int64")+",\n") + } + if this.M != nil { + s = append(s, "M: "+fmt.Sprintf("%#v", this.M)+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringThetest(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&test.NestedDefinition{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.EnumField != nil { + s = append(s, "EnumField: "+valueToGoStringThetest(this.EnumField, "test.NestedDefinition_NestedEnum")+",\n") + } + if this.NNM != nil { + s = append(s, "NNM: "+fmt.Sprintf("%#v", this.NNM)+",\n") + } + if this.NM != nil { + s = append(s, "NM: "+fmt.Sprintf("%#v", this.NM)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition_NestedMessage) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NestedDefinition_NestedMessage{") + if this.NestedField1 != nil { + s = append(s, "NestedField1: "+valueToGoStringThetest(this.NestedField1, "uint64")+",\n") + } + if this.NNM != nil { + s = append(s, "NNM: "+fmt.Sprintf("%#v", this.NNM)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NestedDefinition_NestedMessage_NestedNestedMsg{") + if this.NestedNestedField1 != nil { + s = append(s, "NestedNestedField1: "+valueToGoStringThetest(this.NestedNestedField1, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedScope) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NestedScope{") + if this.A != nil { + s = append(s, "A: "+fmt.Sprintf("%#v", this.A)+",\n") + } + if this.B != nil { + s = append(s, "B: "+valueToGoStringThetest(this.B, "test.NestedDefinition_NestedEnum")+",\n") + } + if this.C != nil { + s = append(s, "C: "+fmt.Sprintf("%#v", this.C)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNativeDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinOptNativeDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+valueToGoStringThetest(this.Field8, "int64")+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+valueToGoStringThetest(this.Field9, "uint32")+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+valueToGoStringThetest(this.Field10, "int32")+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+valueToGoStringThetest(this.Field11, "uint64")+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+valueToGoStringThetest(this.Field12, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomContainer) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.CustomContainer{") + s = append(s, "CustomStruct: "+strings.Replace(this.CustomStruct.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNidOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNidOptNative{") + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + s = append(s, "FieldE: "+fmt.Sprintf("%#v", this.FieldE)+",\n") + s = append(s, "FieldF: "+fmt.Sprintf("%#v", this.FieldF)+",\n") + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + s = append(s, "FieldH: "+fmt.Sprintf("%#v", this.FieldH)+",\n") + s = append(s, "FieldI: "+fmt.Sprintf("%#v", this.FieldI)+",\n") + s = append(s, "FieldJ: "+fmt.Sprintf("%#v", this.FieldJ)+",\n") + s = append(s, "FieldK: "+fmt.Sprintf("%#v", this.FieldK)+",\n") + s = append(s, "FieldL: "+fmt.Sprintf("%#v", this.FieldL)+",\n") + s = append(s, "FieldM: "+fmt.Sprintf("%#v", this.FieldM)+",\n") + s = append(s, "FieldN: "+fmt.Sprintf("%#v", this.FieldN)+",\n") + s = append(s, "FieldO: "+fmt.Sprintf("%#v", this.FieldO)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNinOptNative{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "float64")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "float32")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+valueToGoStringThetest(this.FieldC, "int32")+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+valueToGoStringThetest(this.FieldD, "int64")+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+valueToGoStringThetest(this.FieldE, "uint32")+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+valueToGoStringThetest(this.FieldF, "uint64")+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+valueToGoStringThetest(this.FieldG, "int32")+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+valueToGoStringThetest(this.FieldH, "int64")+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+valueToGoStringThetest(this.FieldI, "uint32")+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+valueToGoStringThetest(this.FieldJ, "int32")+",\n") + } + if this.FieldK != nil { + s = append(s, "FieldK: "+valueToGoStringThetest(this.FieldK, "uint64")+",\n") + } + if this.FielL != nil { + s = append(s, "FielL: "+valueToGoStringThetest(this.FielL, "int64")+",\n") + } + if this.FieldM != nil { + s = append(s, "FieldM: "+valueToGoStringThetest(this.FieldM, "bool")+",\n") + } + if this.FieldN != nil { + s = append(s, "FieldN: "+valueToGoStringThetest(this.FieldN, "string")+",\n") + } + if this.FieldO != nil { + s = append(s, "FieldO: "+valueToGoStringThetest(this.FieldO, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNinRepNative{") + if this.FieldA != nil { + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+fmt.Sprintf("%#v", this.FieldE)+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+fmt.Sprintf("%#v", this.FieldF)+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+fmt.Sprintf("%#v", this.FieldH)+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+fmt.Sprintf("%#v", this.FieldI)+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+fmt.Sprintf("%#v", this.FieldJ)+",\n") + } + if this.FieldK != nil { + s = append(s, "FieldK: "+fmt.Sprintf("%#v", this.FieldK)+",\n") + } + if this.FieldL != nil { + s = append(s, "FieldL: "+fmt.Sprintf("%#v", this.FieldL)+",\n") + } + if this.FieldM != nil { + s = append(s, "FieldM: "+fmt.Sprintf("%#v", this.FieldM)+",\n") + } + if this.FieldN != nil { + s = append(s, "FieldN: "+fmt.Sprintf("%#v", this.FieldN)+",\n") + } + if this.FieldO != nil { + s = append(s, "FieldO: "+fmt.Sprintf("%#v", this.FieldO)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.CustomNameNinStruct{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "float64")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "float32")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+valueToGoStringThetest(this.FieldE, "uint64")+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+valueToGoStringThetest(this.FieldF, "int32")+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+valueToGoStringThetest(this.FieldH, "bool")+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+valueToGoStringThetest(this.FieldI, "string")+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+valueToGoStringThetest(this.FieldJ, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameCustomType) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&test.CustomNameCustomType{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "Uuid")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "github_com_gogo_protobuf_test_custom.Uint128")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinEmbeddedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.CustomNameNinEmbeddedStructUnion{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.FieldA != nil { + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.CustomNameEnum{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "test.TheTestEnum")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NoExtensionsMap) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NoExtensionsMap{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+fmt.Sprintf("%#v", this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Unrecognized) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.Unrecognized{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "string")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithInner) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.UnrecognizedWithInner{") + if this.Embedded != nil { + s = append(s, "Embedded: "+fmt.Sprintf("%#v", this.Embedded)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithInner_Inner) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.UnrecognizedWithInner_Inner{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "uint32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithEmbed) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.UnrecognizedWithEmbed{") + s = append(s, "UnrecognizedWithEmbed_Embedded: "+strings.Replace(this.UnrecognizedWithEmbed_Embedded.GoString(), `&`, ``, 1)+",\n") + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithEmbed_Embedded) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.UnrecognizedWithEmbed_Embedded{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "uint32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringThetest(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringThetest(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedNidOptNative(r randyThetest, easy bool) *NidOptNative { + this := &NidOptNative{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + this.Field5 = uint32(r.Uint32()) + this.Field6 = uint64(uint64(r.Uint32())) + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + this.Field9 = uint32(r.Uint32()) + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + this.Field11 = uint64(uint64(r.Uint32())) + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + this.Field13 = bool(bool(r.Intn(2) == 0)) + this.Field14 = randStringThetest(r) + v1 := r.Intn(100) + this.Field15 = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinOptNative(r randyThetest, easy bool) *NinOptNative { + this := &NinOptNative{} + if r.Intn(10) != 0 { + v2 := float64(r.Float64()) + if r.Intn(2) == 0 { + v2 *= -1 + } + this.Field1 = &v2 + } + if r.Intn(10) != 0 { + v3 := float32(r.Float32()) + if r.Intn(2) == 0 { + v3 *= -1 + } + this.Field2 = &v3 + } + if r.Intn(10) != 0 { + v4 := int32(r.Int31()) + if r.Intn(2) == 0 { + v4 *= -1 + } + this.Field3 = &v4 + } + if r.Intn(10) != 0 { + v5 := int64(r.Int63()) + if r.Intn(2) == 0 { + v5 *= -1 + } + this.Field4 = &v5 + } + if r.Intn(10) != 0 { + v6 := uint32(r.Uint32()) + this.Field5 = &v6 + } + if r.Intn(10) != 0 { + v7 := uint64(uint64(r.Uint32())) + this.Field6 = &v7 + } + if r.Intn(10) != 0 { + v8 := int32(r.Int31()) + if r.Intn(2) == 0 { + v8 *= -1 + } + this.Field7 = &v8 + } + if r.Intn(10) != 0 { + v9 := int64(r.Int63()) + if r.Intn(2) == 0 { + v9 *= -1 + } + this.Field8 = &v9 + } + if r.Intn(10) != 0 { + v10 := uint32(r.Uint32()) + this.Field9 = &v10 + } + if r.Intn(10) != 0 { + v11 := int32(r.Int31()) + if r.Intn(2) == 0 { + v11 *= -1 + } + this.Field10 = &v11 + } + if r.Intn(10) != 0 { + v12 := uint64(uint64(r.Uint32())) + this.Field11 = &v12 + } + if r.Intn(10) != 0 { + v13 := int64(r.Int63()) + if r.Intn(2) == 0 { + v13 *= -1 + } + this.Field12 = &v13 + } + if r.Intn(10) != 0 { + v14 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v14 + } + if r.Intn(10) != 0 { + v15 := randStringThetest(r) + this.Field14 = &v15 + } + if r.Intn(10) != 0 { + v16 := r.Intn(100) + this.Field15 = make([]byte, v16) + for i := 0; i < v16; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepNative(r randyThetest, easy bool) *NidRepNative { + this := &NidRepNative{} + if r.Intn(10) != 0 { + v17 := r.Intn(100) + this.Field1 = make([]float64, v17) + for i := 0; i < v17; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v18 := r.Intn(100) + this.Field2 = make([]float32, v18) + for i := 0; i < v18; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v19 := r.Intn(100) + this.Field3 = make([]int32, v19) + for i := 0; i < v19; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v20 := r.Intn(100) + this.Field4 = make([]int64, v20) + for i := 0; i < v20; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v21 := r.Intn(100) + this.Field5 = make([]uint32, v21) + for i := 0; i < v21; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v22 := r.Intn(100) + this.Field6 = make([]uint64, v22) + for i := 0; i < v22; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v23 := r.Intn(100) + this.Field7 = make([]int32, v23) + for i := 0; i < v23; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v24 := r.Intn(100) + this.Field8 = make([]int64, v24) + for i := 0; i < v24; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v25 := r.Intn(100) + this.Field9 = make([]uint32, v25) + for i := 0; i < v25; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v26 := r.Intn(100) + this.Field10 = make([]int32, v26) + for i := 0; i < v26; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v27 := r.Intn(100) + this.Field11 = make([]uint64, v27) + for i := 0; i < v27; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v28 := r.Intn(100) + this.Field12 = make([]int64, v28) + for i := 0; i < v28; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(100) + this.Field13 = make([]bool, v29) + for i := 0; i < v29; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v30 := r.Intn(10) + this.Field14 = make([]string, v30) + for i := 0; i < v30; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v31 := r.Intn(100) + this.Field15 = make([][]byte, v31) + for i := 0; i < v31; i++ { + v32 := r.Intn(100) + this.Field15[i] = make([]byte, v32) + for j := 0; j < v32; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinRepNative(r randyThetest, easy bool) *NinRepNative { + this := &NinRepNative{} + if r.Intn(10) != 0 { + v33 := r.Intn(100) + this.Field1 = make([]float64, v33) + for i := 0; i < v33; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v34 := r.Intn(100) + this.Field2 = make([]float32, v34) + for i := 0; i < v34; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v35 := r.Intn(100) + this.Field3 = make([]int32, v35) + for i := 0; i < v35; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v36 := r.Intn(100) + this.Field4 = make([]int64, v36) + for i := 0; i < v36; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v37 := r.Intn(100) + this.Field5 = make([]uint32, v37) + for i := 0; i < v37; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v38 := r.Intn(100) + this.Field6 = make([]uint64, v38) + for i := 0; i < v38; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v39 := r.Intn(100) + this.Field7 = make([]int32, v39) + for i := 0; i < v39; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v40 := r.Intn(100) + this.Field8 = make([]int64, v40) + for i := 0; i < v40; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v41 := r.Intn(100) + this.Field9 = make([]uint32, v41) + for i := 0; i < v41; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v42 := r.Intn(100) + this.Field10 = make([]int32, v42) + for i := 0; i < v42; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v43 := r.Intn(100) + this.Field11 = make([]uint64, v43) + for i := 0; i < v43; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v44 := r.Intn(100) + this.Field12 = make([]int64, v44) + for i := 0; i < v44; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v45 := r.Intn(100) + this.Field13 = make([]bool, v45) + for i := 0; i < v45; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v46 := r.Intn(10) + this.Field14 = make([]string, v46) + for i := 0; i < v46; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v47 := r.Intn(100) + this.Field15 = make([][]byte, v47) + for i := 0; i < v47; i++ { + v48 := r.Intn(100) + this.Field15[i] = make([]byte, v48) + for j := 0; j < v48; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepPackedNative(r randyThetest, easy bool) *NidRepPackedNative { + this := &NidRepPackedNative{} + if r.Intn(10) != 0 { + v49 := r.Intn(100) + this.Field1 = make([]float64, v49) + for i := 0; i < v49; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v50 := r.Intn(100) + this.Field2 = make([]float32, v50) + for i := 0; i < v50; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v51 := r.Intn(100) + this.Field3 = make([]int32, v51) + for i := 0; i < v51; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v52 := r.Intn(100) + this.Field4 = make([]int64, v52) + for i := 0; i < v52; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v53 := r.Intn(100) + this.Field5 = make([]uint32, v53) + for i := 0; i < v53; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v54 := r.Intn(100) + this.Field6 = make([]uint64, v54) + for i := 0; i < v54; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v55 := r.Intn(100) + this.Field7 = make([]int32, v55) + for i := 0; i < v55; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v56 := r.Intn(100) + this.Field8 = make([]int64, v56) + for i := 0; i < v56; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v57 := r.Intn(100) + this.Field9 = make([]uint32, v57) + for i := 0; i < v57; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v58 := r.Intn(100) + this.Field10 = make([]int32, v58) + for i := 0; i < v58; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v59 := r.Intn(100) + this.Field11 = make([]uint64, v59) + for i := 0; i < v59; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v60 := r.Intn(100) + this.Field12 = make([]int64, v60) + for i := 0; i < v60; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v61 := r.Intn(100) + this.Field13 = make([]bool, v61) + for i := 0; i < v61; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 14) + } + return this +} + +func NewPopulatedNinRepPackedNative(r randyThetest, easy bool) *NinRepPackedNative { + this := &NinRepPackedNative{} + if r.Intn(10) != 0 { + v62 := r.Intn(100) + this.Field1 = make([]float64, v62) + for i := 0; i < v62; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v63 := r.Intn(100) + this.Field2 = make([]float32, v63) + for i := 0; i < v63; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v64 := r.Intn(100) + this.Field3 = make([]int32, v64) + for i := 0; i < v64; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v65 := r.Intn(100) + this.Field4 = make([]int64, v65) + for i := 0; i < v65; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v66 := r.Intn(100) + this.Field5 = make([]uint32, v66) + for i := 0; i < v66; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v67 := r.Intn(100) + this.Field6 = make([]uint64, v67) + for i := 0; i < v67; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v68 := r.Intn(100) + this.Field7 = make([]int32, v68) + for i := 0; i < v68; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v69 := r.Intn(100) + this.Field8 = make([]int64, v69) + for i := 0; i < v69; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v70 := r.Intn(100) + this.Field9 = make([]uint32, v70) + for i := 0; i < v70; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v71 := r.Intn(100) + this.Field10 = make([]int32, v71) + for i := 0; i < v71; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v72 := r.Intn(100) + this.Field11 = make([]uint64, v72) + for i := 0; i < v72; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v73 := r.Intn(100) + this.Field12 = make([]int64, v73) + for i := 0; i < v73; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v74 := r.Intn(100) + this.Field13 = make([]bool, v74) + for i := 0; i < v74; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 14) + } + return this +} + +func NewPopulatedNidOptStruct(r randyThetest, easy bool) *NidOptStruct { + this := &NidOptStruct{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + v75 := NewPopulatedNidOptNative(r, easy) + this.Field3 = *v75 + v76 := NewPopulatedNinOptNative(r, easy) + this.Field4 = *v76 + this.Field6 = uint64(uint64(r.Uint32())) + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + v77 := NewPopulatedNidOptNative(r, easy) + this.Field8 = *v77 + this.Field13 = bool(bool(r.Intn(2) == 0)) + this.Field14 = randStringThetest(r) + v78 := r.Intn(100) + this.Field15 = make([]byte, v78) + for i := 0; i < v78; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinOptStruct(r randyThetest, easy bool) *NinOptStruct { + this := &NinOptStruct{} + if r.Intn(10) != 0 { + v79 := float64(r.Float64()) + if r.Intn(2) == 0 { + v79 *= -1 + } + this.Field1 = &v79 + } + if r.Intn(10) != 0 { + v80 := float32(r.Float32()) + if r.Intn(2) == 0 { + v80 *= -1 + } + this.Field2 = &v80 + } + if r.Intn(10) != 0 { + this.Field3 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + this.Field4 = NewPopulatedNinOptNative(r, easy) + } + if r.Intn(10) != 0 { + v81 := uint64(uint64(r.Uint32())) + this.Field6 = &v81 + } + if r.Intn(10) != 0 { + v82 := int32(r.Int31()) + if r.Intn(2) == 0 { + v82 *= -1 + } + this.Field7 = &v82 + } + if r.Intn(10) != 0 { + this.Field8 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v83 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v83 + } + if r.Intn(10) != 0 { + v84 := randStringThetest(r) + this.Field14 = &v84 + } + if r.Intn(10) != 0 { + v85 := r.Intn(100) + this.Field15 = make([]byte, v85) + for i := 0; i < v85; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepStruct(r randyThetest, easy bool) *NidRepStruct { + this := &NidRepStruct{} + if r.Intn(10) != 0 { + v86 := r.Intn(100) + this.Field1 = make([]float64, v86) + for i := 0; i < v86; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v87 := r.Intn(100) + this.Field2 = make([]float32, v87) + for i := 0; i < v87; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v88 := r.Intn(10) + this.Field3 = make([]NidOptNative, v88) + for i := 0; i < v88; i++ { + v89 := NewPopulatedNidOptNative(r, easy) + this.Field3[i] = *v89 + } + } + if r.Intn(10) != 0 { + v90 := r.Intn(10) + this.Field4 = make([]NinOptNative, v90) + for i := 0; i < v90; i++ { + v91 := NewPopulatedNinOptNative(r, easy) + this.Field4[i] = *v91 + } + } + if r.Intn(10) != 0 { + v92 := r.Intn(100) + this.Field6 = make([]uint64, v92) + for i := 0; i < v92; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v93 := r.Intn(100) + this.Field7 = make([]int32, v93) + for i := 0; i < v93; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v94 := r.Intn(10) + this.Field8 = make([]NidOptNative, v94) + for i := 0; i < v94; i++ { + v95 := NewPopulatedNidOptNative(r, easy) + this.Field8[i] = *v95 + } + } + if r.Intn(10) != 0 { + v96 := r.Intn(100) + this.Field13 = make([]bool, v96) + for i := 0; i < v96; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v97 := r.Intn(10) + this.Field14 = make([]string, v97) + for i := 0; i < v97; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v98 := r.Intn(100) + this.Field15 = make([][]byte, v98) + for i := 0; i < v98; i++ { + v99 := r.Intn(100) + this.Field15[i] = make([]byte, v99) + for j := 0; j < v99; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinRepStruct(r randyThetest, easy bool) *NinRepStruct { + this := &NinRepStruct{} + if r.Intn(10) != 0 { + v100 := r.Intn(100) + this.Field1 = make([]float64, v100) + for i := 0; i < v100; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v101 := r.Intn(100) + this.Field2 = make([]float32, v101) + for i := 0; i < v101; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v102 := r.Intn(10) + this.Field3 = make([]*NidOptNative, v102) + for i := 0; i < v102; i++ { + this.Field3[i] = NewPopulatedNidOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v103 := r.Intn(10) + this.Field4 = make([]*NinOptNative, v103) + for i := 0; i < v103; i++ { + this.Field4[i] = NewPopulatedNinOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v104 := r.Intn(100) + this.Field6 = make([]uint64, v104) + for i := 0; i < v104; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v105 := r.Intn(100) + this.Field7 = make([]int32, v105) + for i := 0; i < v105; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v106 := r.Intn(10) + this.Field8 = make([]*NidOptNative, v106) + for i := 0; i < v106; i++ { + this.Field8[i] = NewPopulatedNidOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v107 := r.Intn(100) + this.Field13 = make([]bool, v107) + for i := 0; i < v107; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v108 := r.Intn(10) + this.Field14 = make([]string, v108) + for i := 0; i < v108; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v109 := r.Intn(100) + this.Field15 = make([][]byte, v109) + for i := 0; i < v109; i++ { + v110 := r.Intn(100) + this.Field15[i] = make([]byte, v110) + for j := 0; j < v110; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidEmbeddedStruct(r randyThetest, easy bool) *NidEmbeddedStruct { + this := &NidEmbeddedStruct{} + if r.Intn(10) != 0 { + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + } + v111 := NewPopulatedNidOptNative(r, easy) + this.Field200 = *v111 + this.Field210 = bool(bool(r.Intn(2) == 0)) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 211) + } + return this +} + +func NewPopulatedNinEmbeddedStruct(r randyThetest, easy bool) *NinEmbeddedStruct { + this := &NinEmbeddedStruct{} + if r.Intn(10) != 0 { + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + this.Field200 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v112 := bool(bool(r.Intn(2) == 0)) + this.Field210 = &v112 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 211) + } + return this +} + +func NewPopulatedNidNestedStruct(r randyThetest, easy bool) *NidNestedStruct { + this := &NidNestedStruct{} + v113 := NewPopulatedNidOptStruct(r, easy) + this.Field1 = *v113 + if r.Intn(10) != 0 { + v114 := r.Intn(10) + this.Field2 = make([]NidRepStruct, v114) + for i := 0; i < v114; i++ { + v115 := NewPopulatedNidRepStruct(r, easy) + this.Field2[i] = *v115 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinNestedStruct(r randyThetest, easy bool) *NinNestedStruct { + this := &NinNestedStruct{} + if r.Intn(10) != 0 { + this.Field1 = NewPopulatedNinOptStruct(r, easy) + } + if r.Intn(10) != 0 { + v116 := r.Intn(10) + this.Field2 = make([]*NinRepStruct, v116) + for i := 0; i < v116; i++ { + this.Field2[i] = NewPopulatedNinRepStruct(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNidOptCustom(r randyThetest, easy bool) *NidOptCustom { + this := &NidOptCustom{} + v117 := NewPopulatedUuid(r) + this.Id = *v117 + v118 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value = *v118 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedCustomDash(r randyThetest, easy bool) *CustomDash { + this := &CustomDash{} + if r.Intn(10) != 0 { + this.Value = github_com_gogo_protobuf_test_custom_dash_type.NewPopulatedBytes(r) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptCustom(r randyThetest, easy bool) *NinOptCustom { + this := &NinOptCustom{} + if r.Intn(10) != 0 { + this.Id = NewPopulatedUuid(r) + } + if r.Intn(10) != 0 { + this.Value = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNidRepCustom(r randyThetest, easy bool) *NidRepCustom { + this := &NidRepCustom{} + if r.Intn(10) != 0 { + v119 := r.Intn(10) + this.Id = make([]Uuid, v119) + for i := 0; i < v119; i++ { + v120 := NewPopulatedUuid(r) + this.Id[i] = *v120 + } + } + if r.Intn(10) != 0 { + v121 := r.Intn(10) + this.Value = make([]github_com_gogo_protobuf_test_custom.Uint128, v121) + for i := 0; i < v121; i++ { + v122 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value[i] = *v122 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinRepCustom(r randyThetest, easy bool) *NinRepCustom { + this := &NinRepCustom{} + if r.Intn(10) != 0 { + v123 := r.Intn(10) + this.Id = make([]Uuid, v123) + for i := 0; i < v123; i++ { + v124 := NewPopulatedUuid(r) + this.Id[i] = *v124 + } + } + if r.Intn(10) != 0 { + v125 := r.Intn(10) + this.Value = make([]github_com_gogo_protobuf_test_custom.Uint128, v125) + for i := 0; i < v125; i++ { + v126 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value[i] = *v126 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinOptNativeUnion(r randyThetest, easy bool) *NinOptNativeUnion { + this := &NinOptNativeUnion{} + fieldNum := r.Intn(9) + switch fieldNum { + case 0: + v127 := float64(r.Float64()) + if r.Intn(2) == 0 { + v127 *= -1 + } + this.Field1 = &v127 + case 1: + v128 := float32(r.Float32()) + if r.Intn(2) == 0 { + v128 *= -1 + } + this.Field2 = &v128 + case 2: + v129 := int32(r.Int31()) + if r.Intn(2) == 0 { + v129 *= -1 + } + this.Field3 = &v129 + case 3: + v130 := int64(r.Int63()) + if r.Intn(2) == 0 { + v130 *= -1 + } + this.Field4 = &v130 + case 4: + v131 := uint32(r.Uint32()) + this.Field5 = &v131 + case 5: + v132 := uint64(uint64(r.Uint32())) + this.Field6 = &v132 + case 6: + v133 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v133 + case 7: + v134 := randStringThetest(r) + this.Field14 = &v134 + case 8: + v135 := r.Intn(100) + this.Field15 = make([]byte, v135) + for i := 0; i < v135; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + return this +} + +func NewPopulatedNinOptStructUnion(r randyThetest, easy bool) *NinOptStructUnion { + this := &NinOptStructUnion{} + fieldNum := r.Intn(9) + switch fieldNum { + case 0: + v136 := float64(r.Float64()) + if r.Intn(2) == 0 { + v136 *= -1 + } + this.Field1 = &v136 + case 1: + v137 := float32(r.Float32()) + if r.Intn(2) == 0 { + v137 *= -1 + } + this.Field2 = &v137 + case 2: + this.Field3 = NewPopulatedNidOptNative(r, easy) + case 3: + this.Field4 = NewPopulatedNinOptNative(r, easy) + case 4: + v138 := uint64(uint64(r.Uint32())) + this.Field6 = &v138 + case 5: + v139 := int32(r.Int31()) + if r.Intn(2) == 0 { + v139 *= -1 + } + this.Field7 = &v139 + case 6: + v140 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v140 + case 7: + v141 := randStringThetest(r) + this.Field14 = &v141 + case 8: + v142 := r.Intn(100) + this.Field15 = make([]byte, v142) + for i := 0; i < v142; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + return this +} + +func NewPopulatedNinEmbeddedStructUnion(r randyThetest, easy bool) *NinEmbeddedStructUnion { + this := &NinEmbeddedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + case 1: + this.Field200 = NewPopulatedNinOptNative(r, easy) + case 2: + v143 := bool(bool(r.Intn(2) == 0)) + this.Field210 = &v143 + } + return this +} + +func NewPopulatedNinNestedStructUnion(r randyThetest, easy bool) *NinNestedStructUnion { + this := &NinNestedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.Field1 = NewPopulatedNinOptNativeUnion(r, easy) + case 1: + this.Field2 = NewPopulatedNinOptStructUnion(r, easy) + case 2: + this.Field3 = NewPopulatedNinEmbeddedStructUnion(r, easy) + } + return this +} + +func NewPopulatedTree(r randyThetest, easy bool) *Tree { + this := &Tree{} + fieldNum := r.Intn(102) + switch fieldNum { + case 0: + this.Or = NewPopulatedOrBranch(r, easy) + case 1: + this.And = NewPopulatedAndBranch(r, easy) + case 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101: + this.Leaf = NewPopulatedLeaf(r, easy) + } + return this +} + +func NewPopulatedOrBranch(r randyThetest, easy bool) *OrBranch { + this := &OrBranch{} + v144 := NewPopulatedTree(r, easy) + this.Left = *v144 + v145 := NewPopulatedTree(r, easy) + this.Right = *v145 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedAndBranch(r randyThetest, easy bool) *AndBranch { + this := &AndBranch{} + v146 := NewPopulatedTree(r, easy) + this.Left = *v146 + v147 := NewPopulatedTree(r, easy) + this.Right = *v147 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedLeaf(r randyThetest, easy bool) *Leaf { + this := &Leaf{} + this.Value = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Value *= -1 + } + this.StrValue = randStringThetest(r) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedDeepTree(r randyThetest, easy bool) *DeepTree { + this := &DeepTree{} + fieldNum := r.Intn(102) + switch fieldNum { + case 0: + this.Down = NewPopulatedADeepBranch(r, easy) + case 1: + this.And = NewPopulatedAndDeepBranch(r, easy) + case 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101: + this.Leaf = NewPopulatedDeepLeaf(r, easy) + } + return this +} + +func NewPopulatedADeepBranch(r randyThetest, easy bool) *ADeepBranch { + this := &ADeepBranch{} + v148 := NewPopulatedDeepTree(r, easy) + this.Down = *v148 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedAndDeepBranch(r randyThetest, easy bool) *AndDeepBranch { + this := &AndDeepBranch{} + v149 := NewPopulatedDeepTree(r, easy) + this.Left = *v149 + v150 := NewPopulatedDeepTree(r, easy) + this.Right = *v150 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedDeepLeaf(r randyThetest, easy bool) *DeepLeaf { + this := &DeepLeaf{} + v151 := NewPopulatedTree(r, easy) + this.Tree = *v151 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNil(r randyThetest, easy bool) *Nil { + this := &Nil{} + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 1) + } + return this +} + +func NewPopulatedNidOptEnum(r randyThetest, easy bool) *NidOptEnum { + this := &NidOptEnum{} + this.Field1 = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptEnum(r randyThetest, easy bool) *NinOptEnum { + this := &NinOptEnum{} + if r.Intn(10) != 0 { + v152 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.Field1 = &v152 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNidRepEnum(r randyThetest, easy bool) *NidRepEnum { + this := &NidRepEnum{} + if r.Intn(10) != 0 { + v153 := r.Intn(10) + this.Field1 = make([]TheTestEnum, v153) + for i := 0; i < v153; i++ { + this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinRepEnum(r randyThetest, easy bool) *NinRepEnum { + this := &NinRepEnum{} + if r.Intn(10) != 0 { + v154 := r.Intn(10) + this.Field1 = make([]TheTestEnum, v154) + for i := 0; i < v154; i++ { + this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptEnumDefault(r randyThetest, easy bool) *NinOptEnumDefault { + this := &NinOptEnumDefault{} + if r.Intn(10) != 0 { + v155 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.Field1 = &v155 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedAnotherNinOptEnum(r randyThetest, easy bool) *AnotherNinOptEnum { + this := &AnotherNinOptEnum{} + if r.Intn(10) != 0 { + v156 := AnotherTestEnum([]int32{10, 11}[r.Intn(2)]) + this.Field1 = &v156 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedAnotherNinOptEnumDefault(r randyThetest, easy bool) *AnotherNinOptEnumDefault { + this := &AnotherNinOptEnumDefault{} + if r.Intn(10) != 0 { + v157 := AnotherTestEnum([]int32{10, 11}[r.Intn(2)]) + this.Field1 = &v157 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedTimer(r randyThetest, easy bool) *Timer { + this := &Timer{} + this.Time1 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Time1 *= -1 + } + this.Time2 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Time2 *= -1 + } + v158 := r.Intn(100) + this.Data = make([]byte, v158) + for i := 0; i < v158; i++ { + this.Data[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 4) + } + return this +} + +func NewPopulatedMyExtendable(r randyThetest, easy bool) *MyExtendable { + this := &MyExtendable{} + if r.Intn(10) != 0 { + v159 := int64(r.Int63()) + if r.Intn(2) == 0 { + v159 *= -1 + } + this.Field1 = &v159 + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + fieldNumber := r.Intn(100) + 100 + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 201) + } + return this +} + +func NewPopulatedOtherExtenable(r randyThetest, easy bool) *OtherExtenable { + this := &OtherExtenable{} + if r.Intn(10) != 0 { + v160 := int64(r.Int63()) + if r.Intn(2) == 0 { + v160 *= -1 + } + this.Field2 = &v160 + } + if r.Intn(10) != 0 { + v161 := int64(r.Int63()) + if r.Intn(2) == 0 { + v161 *= -1 + } + this.Field13 = &v161 + } + if r.Intn(10) != 0 { + this.M = NewPopulatedMyExtendable(r, easy) + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + eIndex := r.Intn(2) + fieldNumber := 0 + switch eIndex { + case 0: + fieldNumber = r.Intn(3) + 14 + case 1: + fieldNumber = r.Intn(3) + 10 + } + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 18) + } + return this +} + +func NewPopulatedNestedDefinition(r randyThetest, easy bool) *NestedDefinition { + this := &NestedDefinition{} + if r.Intn(10) != 0 { + v162 := int64(r.Int63()) + if r.Intn(2) == 0 { + v162 *= -1 + } + this.Field1 = &v162 + } + if r.Intn(10) != 0 { + v163 := NestedDefinition_NestedEnum([]int32{1}[r.Intn(1)]) + this.EnumField = &v163 + } + if r.Intn(10) != 0 { + this.NNM = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if r.Intn(10) != 0 { + this.NM = NewPopulatedNestedDefinition_NestedMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 5) + } + return this +} + +func NewPopulatedNestedDefinition_NestedMessage(r randyThetest, easy bool) *NestedDefinition_NestedMessage { + this := &NestedDefinition_NestedMessage{} + if r.Intn(10) != 0 { + v164 := uint64(uint64(r.Uint32())) + this.NestedField1 = &v164 + } + if r.Intn(10) != 0 { + this.NNM = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r randyThetest, easy bool) *NestedDefinition_NestedMessage_NestedNestedMsg { + this := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if r.Intn(10) != 0 { + v165 := randStringThetest(r) + this.NestedNestedField1 = &v165 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 11) + } + return this +} + +func NewPopulatedNestedScope(r randyThetest, easy bool) *NestedScope { + this := &NestedScope{} + if r.Intn(10) != 0 { + this.A = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if r.Intn(10) != 0 { + v166 := NestedDefinition_NestedEnum([]int32{1}[r.Intn(1)]) + this.B = &v166 + } + if r.Intn(10) != 0 { + this.C = NewPopulatedNestedDefinition_NestedMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 4) + } + return this +} + +func NewPopulatedNinOptNativeDefault(r randyThetest, easy bool) *NinOptNativeDefault { + this := &NinOptNativeDefault{} + if r.Intn(10) != 0 { + v167 := float64(r.Float64()) + if r.Intn(2) == 0 { + v167 *= -1 + } + this.Field1 = &v167 + } + if r.Intn(10) != 0 { + v168 := float32(r.Float32()) + if r.Intn(2) == 0 { + v168 *= -1 + } + this.Field2 = &v168 + } + if r.Intn(10) != 0 { + v169 := int32(r.Int31()) + if r.Intn(2) == 0 { + v169 *= -1 + } + this.Field3 = &v169 + } + if r.Intn(10) != 0 { + v170 := int64(r.Int63()) + if r.Intn(2) == 0 { + v170 *= -1 + } + this.Field4 = &v170 + } + if r.Intn(10) != 0 { + v171 := uint32(r.Uint32()) + this.Field5 = &v171 + } + if r.Intn(10) != 0 { + v172 := uint64(uint64(r.Uint32())) + this.Field6 = &v172 + } + if r.Intn(10) != 0 { + v173 := int32(r.Int31()) + if r.Intn(2) == 0 { + v173 *= -1 + } + this.Field7 = &v173 + } + if r.Intn(10) != 0 { + v174 := int64(r.Int63()) + if r.Intn(2) == 0 { + v174 *= -1 + } + this.Field8 = &v174 + } + if r.Intn(10) != 0 { + v175 := uint32(r.Uint32()) + this.Field9 = &v175 + } + if r.Intn(10) != 0 { + v176 := int32(r.Int31()) + if r.Intn(2) == 0 { + v176 *= -1 + } + this.Field10 = &v176 + } + if r.Intn(10) != 0 { + v177 := uint64(uint64(r.Uint32())) + this.Field11 = &v177 + } + if r.Intn(10) != 0 { + v178 := int64(r.Int63()) + if r.Intn(2) == 0 { + v178 *= -1 + } + this.Field12 = &v178 + } + if r.Intn(10) != 0 { + v179 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v179 + } + if r.Intn(10) != 0 { + v180 := randStringThetest(r) + this.Field14 = &v180 + } + if r.Intn(10) != 0 { + v181 := r.Intn(100) + this.Field15 = make([]byte, v181) + for i := 0; i < v181; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomContainer(r randyThetest, easy bool) *CustomContainer { + this := &CustomContainer{} + v182 := NewPopulatedNidOptCustom(r, easy) + this.CustomStruct = *v182 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedCustomNameNidOptNative(r randyThetest, easy bool) *CustomNameNidOptNative { + this := &CustomNameNidOptNative{} + this.FieldA = float64(r.Float64()) + if r.Intn(2) == 0 { + this.FieldA *= -1 + } + this.FieldB = float32(r.Float32()) + if r.Intn(2) == 0 { + this.FieldB *= -1 + } + this.FieldC = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldC *= -1 + } + this.FieldD = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldD *= -1 + } + this.FieldE = uint32(r.Uint32()) + this.FieldF = uint64(uint64(r.Uint32())) + this.FieldG = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldG *= -1 + } + this.FieldH = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldH *= -1 + } + this.FieldI = uint32(r.Uint32()) + this.FieldJ = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldJ *= -1 + } + this.FieldK = uint64(uint64(r.Uint32())) + this.FieldL = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldL *= -1 + } + this.FieldM = bool(bool(r.Intn(2) == 0)) + this.FieldN = randStringThetest(r) + v183 := r.Intn(100) + this.FieldO = make([]byte, v183) + for i := 0; i < v183; i++ { + this.FieldO[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinOptNative(r randyThetest, easy bool) *CustomNameNinOptNative { + this := &CustomNameNinOptNative{} + if r.Intn(10) != 0 { + v184 := float64(r.Float64()) + if r.Intn(2) == 0 { + v184 *= -1 + } + this.FieldA = &v184 + } + if r.Intn(10) != 0 { + v185 := float32(r.Float32()) + if r.Intn(2) == 0 { + v185 *= -1 + } + this.FieldB = &v185 + } + if r.Intn(10) != 0 { + v186 := int32(r.Int31()) + if r.Intn(2) == 0 { + v186 *= -1 + } + this.FieldC = &v186 + } + if r.Intn(10) != 0 { + v187 := int64(r.Int63()) + if r.Intn(2) == 0 { + v187 *= -1 + } + this.FieldD = &v187 + } + if r.Intn(10) != 0 { + v188 := uint32(r.Uint32()) + this.FieldE = &v188 + } + if r.Intn(10) != 0 { + v189 := uint64(uint64(r.Uint32())) + this.FieldF = &v189 + } + if r.Intn(10) != 0 { + v190 := int32(r.Int31()) + if r.Intn(2) == 0 { + v190 *= -1 + } + this.FieldG = &v190 + } + if r.Intn(10) != 0 { + v191 := int64(r.Int63()) + if r.Intn(2) == 0 { + v191 *= -1 + } + this.FieldH = &v191 + } + if r.Intn(10) != 0 { + v192 := uint32(r.Uint32()) + this.FieldI = &v192 + } + if r.Intn(10) != 0 { + v193 := int32(r.Int31()) + if r.Intn(2) == 0 { + v193 *= -1 + } + this.FieldJ = &v193 + } + if r.Intn(10) != 0 { + v194 := uint64(uint64(r.Uint32())) + this.FieldK = &v194 + } + if r.Intn(10) != 0 { + v195 := int64(r.Int63()) + if r.Intn(2) == 0 { + v195 *= -1 + } + this.FielL = &v195 + } + if r.Intn(10) != 0 { + v196 := bool(bool(r.Intn(2) == 0)) + this.FieldM = &v196 + } + if r.Intn(10) != 0 { + v197 := randStringThetest(r) + this.FieldN = &v197 + } + if r.Intn(10) != 0 { + v198 := r.Intn(100) + this.FieldO = make([]byte, v198) + for i := 0; i < v198; i++ { + this.FieldO[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinRepNative(r randyThetest, easy bool) *CustomNameNinRepNative { + this := &CustomNameNinRepNative{} + if r.Intn(10) != 0 { + v199 := r.Intn(100) + this.FieldA = make([]float64, v199) + for i := 0; i < v199; i++ { + this.FieldA[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.FieldA[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v200 := r.Intn(100) + this.FieldB = make([]float32, v200) + for i := 0; i < v200; i++ { + this.FieldB[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.FieldB[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v201 := r.Intn(100) + this.FieldC = make([]int32, v201) + for i := 0; i < v201; i++ { + this.FieldC[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldC[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v202 := r.Intn(100) + this.FieldD = make([]int64, v202) + for i := 0; i < v202; i++ { + this.FieldD[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldD[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v203 := r.Intn(100) + this.FieldE = make([]uint32, v203) + for i := 0; i < v203; i++ { + this.FieldE[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v204 := r.Intn(100) + this.FieldF = make([]uint64, v204) + for i := 0; i < v204; i++ { + this.FieldF[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v205 := r.Intn(100) + this.FieldG = make([]int32, v205) + for i := 0; i < v205; i++ { + this.FieldG[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldG[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v206 := r.Intn(100) + this.FieldH = make([]int64, v206) + for i := 0; i < v206; i++ { + this.FieldH[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldH[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v207 := r.Intn(100) + this.FieldI = make([]uint32, v207) + for i := 0; i < v207; i++ { + this.FieldI[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v208 := r.Intn(100) + this.FieldJ = make([]int32, v208) + for i := 0; i < v208; i++ { + this.FieldJ[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldJ[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v209 := r.Intn(100) + this.FieldK = make([]uint64, v209) + for i := 0; i < v209; i++ { + this.FieldK[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v210 := r.Intn(100) + this.FieldL = make([]int64, v210) + for i := 0; i < v210; i++ { + this.FieldL[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldL[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v211 := r.Intn(100) + this.FieldM = make([]bool, v211) + for i := 0; i < v211; i++ { + this.FieldM[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v212 := r.Intn(10) + this.FieldN = make([]string, v212) + for i := 0; i < v212; i++ { + this.FieldN[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v213 := r.Intn(100) + this.FieldO = make([][]byte, v213) + for i := 0; i < v213; i++ { + v214 := r.Intn(100) + this.FieldO[i] = make([]byte, v214) + for j := 0; j < v214; j++ { + this.FieldO[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinStruct(r randyThetest, easy bool) *CustomNameNinStruct { + this := &CustomNameNinStruct{} + if r.Intn(10) != 0 { + v215 := float64(r.Float64()) + if r.Intn(2) == 0 { + v215 *= -1 + } + this.FieldA = &v215 + } + if r.Intn(10) != 0 { + v216 := float32(r.Float32()) + if r.Intn(2) == 0 { + v216 *= -1 + } + this.FieldB = &v216 + } + if r.Intn(10) != 0 { + this.FieldC = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v217 := r.Intn(10) + this.FieldD = make([]*NinOptNative, v217) + for i := 0; i < v217; i++ { + this.FieldD[i] = NewPopulatedNinOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v218 := uint64(uint64(r.Uint32())) + this.FieldE = &v218 + } + if r.Intn(10) != 0 { + v219 := int32(r.Int31()) + if r.Intn(2) == 0 { + v219 *= -1 + } + this.FieldF = &v219 + } + if r.Intn(10) != 0 { + this.FieldG = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v220 := bool(bool(r.Intn(2) == 0)) + this.FieldH = &v220 + } + if r.Intn(10) != 0 { + v221 := randStringThetest(r) + this.FieldI = &v221 + } + if r.Intn(10) != 0 { + v222 := r.Intn(100) + this.FieldJ = make([]byte, v222) + for i := 0; i < v222; i++ { + this.FieldJ[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameCustomType(r randyThetest, easy bool) *CustomNameCustomType { + this := &CustomNameCustomType{} + if r.Intn(10) != 0 { + this.FieldA = NewPopulatedUuid(r) + } + if r.Intn(10) != 0 { + this.FieldB = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + } + if r.Intn(10) != 0 { + v223 := r.Intn(10) + this.FieldC = make([]Uuid, v223) + for i := 0; i < v223; i++ { + v224 := NewPopulatedUuid(r) + this.FieldC[i] = *v224 + } + } + if r.Intn(10) != 0 { + v225 := r.Intn(10) + this.FieldD = make([]github_com_gogo_protobuf_test_custom.Uint128, v225) + for i := 0; i < v225; i++ { + v226 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.FieldD[i] = *v226 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 5) + } + return this +} + +func NewPopulatedCustomNameNinEmbeddedStructUnion(r randyThetest, easy bool) *CustomNameNinEmbeddedStructUnion { + this := &CustomNameNinEmbeddedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + case 1: + this.FieldA = NewPopulatedNinOptNative(r, easy) + case 2: + v227 := bool(bool(r.Intn(2) == 0)) + this.FieldB = &v227 + } + return this +} + +func NewPopulatedCustomNameEnum(r randyThetest, easy bool) *CustomNameEnum { + this := &CustomNameEnum{} + if r.Intn(10) != 0 { + v228 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.FieldA = &v228 + } + if r.Intn(10) != 0 { + v229 := r.Intn(10) + this.FieldB = make([]TheTestEnum, v229) + for i := 0; i < v229; i++ { + this.FieldB[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNoExtensionsMap(r randyThetest, easy bool) *NoExtensionsMap { + this := &NoExtensionsMap{} + if r.Intn(10) != 0 { + v230 := int64(r.Int63()) + if r.Intn(2) == 0 { + v230 *= -1 + } + this.Field1 = &v230 + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + fieldNumber := r.Intn(100) + 100 + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 201) + } + return this +} + +func NewPopulatedUnrecognized(r randyThetest, easy bool) *Unrecognized { + this := &Unrecognized{} + if r.Intn(10) != 0 { + v231 := randStringThetest(r) + this.Field1 = &v231 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedUnrecognizedWithInner(r randyThetest, easy bool) *UnrecognizedWithInner { + this := &UnrecognizedWithInner{} + if r.Intn(10) != 0 { + v232 := r.Intn(10) + this.Embedded = make([]*UnrecognizedWithInner_Inner, v232) + for i := 0; i < v232; i++ { + this.Embedded[i] = NewPopulatedUnrecognizedWithInner_Inner(r, easy) + } + } + if r.Intn(10) != 0 { + v233 := randStringThetest(r) + this.Field2 = &v233 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedUnrecognizedWithInner_Inner(r randyThetest, easy bool) *UnrecognizedWithInner_Inner { + this := &UnrecognizedWithInner_Inner{} + if r.Intn(10) != 0 { + v234 := uint32(r.Uint32()) + this.Field1 = &v234 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedUnrecognizedWithEmbed(r randyThetest, easy bool) *UnrecognizedWithEmbed { + this := &UnrecognizedWithEmbed{} + v235 := NewPopulatedUnrecognizedWithEmbed_Embedded(r, easy) + this.UnrecognizedWithEmbed_Embedded = *v235 + if r.Intn(10) != 0 { + v236 := randStringThetest(r) + this.Field2 = &v236 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedUnrecognizedWithEmbed_Embedded(r randyThetest, easy bool) *UnrecognizedWithEmbed_Embedded { + this := &UnrecognizedWithEmbed_Embedded{} + if r.Intn(10) != 0 { + v237 := uint32(r.Uint32()) + this.Field1 = &v237 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +type randyThetest interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneThetest(r randyThetest) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringThetest(r randyThetest) string { + v238 := r.Intn(100) + tmps := make([]rune, v238) + for i := 0; i < v238; i++ { + tmps[i] = randUTF8RuneThetest(r) + } + return string(tmps) +} +func randUnrecognizedThetest(r randyThetest, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldThetest(data, r, fieldNumber, wire) + } + return data +} +func randFieldThetest(data []byte, r randyThetest, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateThetest(data, uint64(key)) + v239 := r.Int63() + if r.Intn(2) == 0 { + v239 *= -1 + } + data = encodeVarintPopulateThetest(data, uint64(v239)) + case 1: + data = encodeVarintPopulateThetest(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateThetest(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateThetest(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateThetest(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateThetest(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *NidOptNative) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + n += 1 + sovThetest(uint64(m.Field3)) + n += 1 + sovThetest(uint64(m.Field4)) + n += 1 + sovThetest(uint64(m.Field5)) + n += 1 + sovThetest(uint64(m.Field6)) + n += 1 + sozThetest(uint64(m.Field7)) + n += 1 + sozThetest(uint64(m.Field8)) + n += 5 + n += 5 + n += 9 + n += 9 + n += 2 + l = len(m.Field14) + n += 1 + l + sovThetest(uint64(l)) + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNative) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + n += 1 + sozThetest(uint64(*m.Field8)) + } + if m.Field9 != nil { + n += 5 + } + if m.Field10 != nil { + n += 5 + } + if m.Field11 != nil { + n += 9 + } + if m.Field12 != nil { + n += 9 + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field5) > 0 { + for _, e := range m.Field5 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field9) > 0 { + n += 5 * len(m.Field9) + } + if len(m.Field10) > 0 { + n += 5 * len(m.Field10) + } + if len(m.Field11) > 0 { + n += 9 * len(m.Field11) + } + if len(m.Field12) > 0 { + n += 9 * len(m.Field12) + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field5) > 0 { + for _, e := range m.Field5 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field9) > 0 { + n += 5 * len(m.Field9) + } + if len(m.Field10) > 0 { + n += 5 * len(m.Field10) + } + if len(m.Field11) > 0 { + n += 9 * len(m.Field11) + } + if len(m.Field12) > 0 { + n += 9 * len(m.Field12) + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepPackedNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 1 + sovThetest(uint64(len(m.Field1)*8)) + len(m.Field1)*8 + } + if len(m.Field2) > 0 { + n += 1 + sovThetest(uint64(len(m.Field2)*4)) + len(m.Field2)*4 + } + if len(m.Field3) > 0 { + l = 0 + for _, e := range m.Field3 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field4) > 0 { + l = 0 + for _, e := range m.Field4 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field5) > 0 { + l = 0 + for _, e := range m.Field5 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field6) > 0 { + l = 0 + for _, e := range m.Field6 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field7) > 0 { + l = 0 + for _, e := range m.Field7 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field8) > 0 { + l = 0 + for _, e := range m.Field8 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field9) > 0 { + n += 1 + sovThetest(uint64(len(m.Field9)*4)) + len(m.Field9)*4 + } + if len(m.Field10) > 0 { + n += 1 + sovThetest(uint64(len(m.Field10)*4)) + len(m.Field10)*4 + } + if len(m.Field11) > 0 { + n += 1 + sovThetest(uint64(len(m.Field11)*8)) + len(m.Field11)*8 + } + if len(m.Field12) > 0 { + n += 1 + sovThetest(uint64(len(m.Field12)*8)) + len(m.Field12)*8 + } + if len(m.Field13) > 0 { + n += 1 + sovThetest(uint64(len(m.Field13))) + len(m.Field13)*1 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepPackedNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 1 + sovThetest(uint64(len(m.Field1)*8)) + len(m.Field1)*8 + } + if len(m.Field2) > 0 { + n += 1 + sovThetest(uint64(len(m.Field2)*4)) + len(m.Field2)*4 + } + if len(m.Field3) > 0 { + l = 0 + for _, e := range m.Field3 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field4) > 0 { + l = 0 + for _, e := range m.Field4 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field5) > 0 { + l = 0 + for _, e := range m.Field5 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field6) > 0 { + l = 0 + for _, e := range m.Field6 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field7) > 0 { + l = 0 + for _, e := range m.Field7 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field8) > 0 { + l = 0 + for _, e := range m.Field8 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field9) > 0 { + n += 1 + sovThetest(uint64(len(m.Field9)*4)) + len(m.Field9)*4 + } + if len(m.Field10) > 0 { + n += 1 + sovThetest(uint64(len(m.Field10)*4)) + len(m.Field10)*4 + } + if len(m.Field11) > 0 { + n += 1 + sovThetest(uint64(len(m.Field11)*8)) + len(m.Field11)*8 + } + if len(m.Field12) > 0 { + n += 1 + sovThetest(uint64(len(m.Field12)*8)) + len(m.Field12)*8 + } + if len(m.Field13) > 0 { + n += 1 + sovThetest(uint64(len(m.Field13))) + len(m.Field13)*1 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptStruct) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + n += 1 + sovThetest(uint64(m.Field6)) + n += 1 + sozThetest(uint64(m.Field7)) + l = m.Field8.Size() + n += 1 + l + sovThetest(uint64(l)) + n += 2 + l = len(m.Field14) + n += 1 + l + sovThetest(uint64(l)) + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptStruct) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field4 != nil { + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + l = m.Field8.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepStruct) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepStruct) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidEmbeddedStruct) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + n += 3 + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinEmbeddedStruct) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field200 != nil { + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.Field210 != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidNestedStruct) Size() (n int) { + var l int + _ = l + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + if len(m.Field2) > 0 { + for _, e := range m.Field2 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinNestedStruct) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.Field2) > 0 { + for _, e := range m.Field2 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptCustom) Size() (n int) { + var l int + _ = l + l = m.Id.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomDash) Size() (n int) { + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptCustom) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepCustom) Size() (n int) { + var l int + _ = l + if len(m.Id) > 0 { + for _, e := range m.Id { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Value) > 0 { + for _, e := range m.Value { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepCustom) Size() (n int) { + var l int + _ = l + if len(m.Id) > 0 { + for _, e := range m.Id { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Value) > 0 { + for _, e := range m.Value { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNativeUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptStructUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field4 != nil { + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinEmbeddedStructUnion) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field200 != nil { + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.Field210 != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinNestedStructUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field2 != nil { + l = m.Field2.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Tree) Size() (n int) { + var l int + _ = l + if m.Or != nil { + l = m.Or.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.And != nil { + l = m.And.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Leaf != nil { + l = m.Leaf.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *OrBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AndBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Leaf) Size() (n int) { + var l int + _ = l + n += 1 + sovThetest(uint64(m.Value)) + l = len(m.StrValue) + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DeepTree) Size() (n int) { + var l int + _ = l + if m.Down != nil { + l = m.Down.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.And != nil { + l = m.And.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Leaf != nil { + l = m.Leaf.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ADeepBranch) Size() (n int) { + var l int + _ = l + l = m.Down.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AndDeepBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DeepLeaf) Size() (n int) { + var l int + _ = l + l = m.Tree.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Nil) Size() (n int) { + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptEnum) Size() (n int) { + var l int + _ = l + n += 1 + sovThetest(uint64(m.Field1)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptEnum) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepEnum) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + for _, e := range m.Field1 { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepEnum) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + for _, e := range m.Field1 { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptEnumDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AnotherNinOptEnum) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AnotherNinOptEnumDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Timer) Size() (n int) { + var l int + _ = l + n += 9 + n += 9 + if m.Data != nil { + l = len(m.Data) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *MyExtendable) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + n += github_com_gogo_protobuf_proto.SizeOfExtensionMap(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *OtherExtenable) Size() (n int) { + var l int + _ = l + if m.Field2 != nil { + n += 1 + sovThetest(uint64(*m.Field2)) + } + if m.Field13 != nil { + n += 1 + sovThetest(uint64(*m.Field13)) + } + if m.M != nil { + l = m.M.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_extensions != nil { + n += github_com_gogo_protobuf_proto.SizeOfExtensionMap(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.EnumField != nil { + n += 1 + sovThetest(uint64(*m.EnumField)) + } + if m.NNM != nil { + l = m.NNM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.NM != nil { + l = m.NM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition_NestedMessage) Size() (n int) { + var l int + _ = l + if m.NestedField1 != nil { + n += 9 + } + if m.NNM != nil { + l = m.NNM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Size() (n int) { + var l int + _ = l + if m.NestedNestedField1 != nil { + l = len(*m.NestedNestedField1) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedScope) Size() (n int) { + var l int + _ = l + if m.A != nil { + l = m.A.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.B != nil { + n += 1 + sovThetest(uint64(*m.B)) + } + if m.C != nil { + l = m.C.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNativeDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + n += 1 + sozThetest(uint64(*m.Field8)) + } + if m.Field9 != nil { + n += 5 + } + if m.Field10 != nil { + n += 5 + } + if m.Field11 != nil { + n += 9 + } + if m.Field12 != nil { + n += 9 + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomContainer) Size() (n int) { + var l int + _ = l + l = m.CustomStruct.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNidOptNative) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + n += 1 + sovThetest(uint64(m.FieldC)) + n += 1 + sovThetest(uint64(m.FieldD)) + n += 1 + sovThetest(uint64(m.FieldE)) + n += 1 + sovThetest(uint64(m.FieldF)) + n += 1 + sozThetest(uint64(m.FieldG)) + n += 1 + sozThetest(uint64(m.FieldH)) + n += 5 + n += 5 + n += 9 + n += 9 + n += 2 + l = len(m.FieldN) + n += 1 + l + sovThetest(uint64(l)) + if m.FieldO != nil { + l = len(m.FieldO) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinOptNative) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 9 + } + if m.FieldB != nil { + n += 5 + } + if m.FieldC != nil { + n += 1 + sovThetest(uint64(*m.FieldC)) + } + if m.FieldD != nil { + n += 1 + sovThetest(uint64(*m.FieldD)) + } + if m.FieldE != nil { + n += 1 + sovThetest(uint64(*m.FieldE)) + } + if m.FieldF != nil { + n += 1 + sovThetest(uint64(*m.FieldF)) + } + if m.FieldG != nil { + n += 1 + sozThetest(uint64(*m.FieldG)) + } + if m.FieldH != nil { + n += 1 + sozThetest(uint64(*m.FieldH)) + } + if m.FieldI != nil { + n += 5 + } + if m.FieldJ != nil { + n += 5 + } + if m.FieldK != nil { + n += 9 + } + if m.FielL != nil { + n += 9 + } + if m.FieldM != nil { + n += 2 + } + if m.FieldN != nil { + l = len(*m.FieldN) + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldO != nil { + l = len(m.FieldO) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinRepNative) Size() (n int) { + var l int + _ = l + if len(m.FieldA) > 0 { + n += 9 * len(m.FieldA) + } + if len(m.FieldB) > 0 { + n += 5 * len(m.FieldB) + } + if len(m.FieldC) > 0 { + for _, e := range m.FieldC { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldE) > 0 { + for _, e := range m.FieldE { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldF) > 0 { + for _, e := range m.FieldF { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldG) > 0 { + for _, e := range m.FieldG { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.FieldH) > 0 { + for _, e := range m.FieldH { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.FieldI) > 0 { + n += 5 * len(m.FieldI) + } + if len(m.FieldJ) > 0 { + n += 5 * len(m.FieldJ) + } + if len(m.FieldK) > 0 { + n += 9 * len(m.FieldK) + } + if len(m.FieldL) > 0 { + n += 9 * len(m.FieldL) + } + if len(m.FieldM) > 0 { + n += 2 * len(m.FieldM) + } + if len(m.FieldN) > 0 { + for _, s := range m.FieldN { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.FieldO) > 0 { + for _, b := range m.FieldO { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinStruct) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 9 + } + if m.FieldB != nil { + n += 5 + } + if m.FieldC != nil { + l = m.FieldC.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.FieldE != nil { + n += 1 + sovThetest(uint64(*m.FieldE)) + } + if m.FieldF != nil { + n += 1 + sozThetest(uint64(*m.FieldF)) + } + if m.FieldG != nil { + l = m.FieldG.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldH != nil { + n += 2 + } + if m.FieldI != nil { + l = len(*m.FieldI) + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldJ != nil { + l = len(m.FieldJ) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameCustomType) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + l = m.FieldA.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldB != nil { + l = m.FieldB.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.FieldC) > 0 { + for _, e := range m.FieldC { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinEmbeddedStructUnion) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldA != nil { + l = m.FieldA.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.FieldB != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameEnum) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 1 + sovThetest(uint64(*m.FieldA)) + } + if len(m.FieldB) > 0 { + for _, e := range m.FieldB { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NoExtensionsMap) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + n += len(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Unrecognized) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = len(*m.Field1) + n += 1 + l + sovThetest(uint64(l)) + } + return n +} + +func (m *UnrecognizedWithInner) Size() (n int) { + var l int + _ = l + if len(m.Embedded) > 0 { + for _, e := range m.Embedded { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.Field2 != nil { + l = len(*m.Field2) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UnrecognizedWithInner_Inner) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + return n +} + +func (m *UnrecognizedWithEmbed) Size() (n int) { + var l int + _ = l + l = m.UnrecognizedWithEmbed_Embedded.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.Field2 != nil { + l = len(*m.Field2) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UnrecognizedWithEmbed_Embedded) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + return n +} + +func sovThetest(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozThetest(x uint64) (n int) { + return sovThetest(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *NidOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNative{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + valueToStringThetest(this.Field8) + `,`, + `Field9:` + valueToStringThetest(this.Field9) + `,`, + `Field10:` + valueToStringThetest(this.Field10) + `,`, + `Field11:` + valueToStringThetest(this.Field11) + `,`, + `Field12:` + valueToStringThetest(this.Field12) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepPackedNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepPackedNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepPackedNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepPackedNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(strings.Replace(this.Field3.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field4:` + strings.Replace(strings.Replace(this.Field4.String(), "NinOptNative", "NinOptNative", 1), `&`, ``, 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(strings.Replace(this.Field8.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptStruct{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field4:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1), `&`, ``, 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidEmbeddedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidEmbeddedStruct{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(strings.Replace(this.Field200.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field210:` + fmt.Sprintf("%v", this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinEmbeddedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinEmbeddedStruct{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(fmt.Sprintf("%v", this.Field200), "NidOptNative", "NidOptNative", 1) + `,`, + `Field210:` + valueToStringThetest(this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidNestedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidNestedStruct{`, + `Field1:` + strings.Replace(strings.Replace(this.Field1.String(), "NidOptStruct", "NidOptStruct", 1), `&`, ``, 1) + `,`, + `Field2:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field2), "NidRepStruct", "NidRepStruct", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinNestedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinNestedStruct{`, + `Field1:` + strings.Replace(fmt.Sprintf("%v", this.Field1), "NinOptStruct", "NinOptStruct", 1) + `,`, + `Field2:` + strings.Replace(fmt.Sprintf("%v", this.Field2), "NinRepStruct", "NinRepStruct", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomDash) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomDash{`, + `Value:` + valueToStringThetest(this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptCustom{`, + `Id:` + valueToStringThetest(this.Id) + `,`, + `Value:` + valueToStringThetest(this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNativeUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNativeUnion{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptStructUnion{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinEmbeddedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinEmbeddedStructUnion{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(fmt.Sprintf("%v", this.Field200), "NinOptNative", "NinOptNative", 1) + `,`, + `Field210:` + valueToStringThetest(this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinNestedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinNestedStructUnion{`, + `Field1:` + strings.Replace(fmt.Sprintf("%v", this.Field1), "NinOptNativeUnion", "NinOptNativeUnion", 1) + `,`, + `Field2:` + strings.Replace(fmt.Sprintf("%v", this.Field2), "NinOptStructUnion", "NinOptStructUnion", 1) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NinEmbeddedStructUnion", "NinEmbeddedStructUnion", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Tree) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Tree{`, + `Or:` + strings.Replace(fmt.Sprintf("%v", this.Or), "OrBranch", "OrBranch", 1) + `,`, + `And:` + strings.Replace(fmt.Sprintf("%v", this.And), "AndBranch", "AndBranch", 1) + `,`, + `Leaf:` + strings.Replace(fmt.Sprintf("%v", this.Leaf), "Leaf", "Leaf", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OrBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OrBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AndBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AndBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Leaf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Leaf{`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `StrValue:` + fmt.Sprintf("%v", this.StrValue) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *DeepTree) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DeepTree{`, + `Down:` + strings.Replace(fmt.Sprintf("%v", this.Down), "ADeepBranch", "ADeepBranch", 1) + `,`, + `And:` + strings.Replace(fmt.Sprintf("%v", this.And), "AndDeepBranch", "AndDeepBranch", 1) + `,`, + `Leaf:` + strings.Replace(fmt.Sprintf("%v", this.Leaf), "DeepLeaf", "DeepLeaf", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ADeepBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ADeepBranch{`, + `Down:` + strings.Replace(strings.Replace(this.Down.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AndDeepBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AndDeepBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *DeepLeaf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DeepLeaf{`, + `Tree:` + strings.Replace(strings.Replace(this.Tree.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Nil) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Nil{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptEnum{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptEnumDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptEnumDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AnotherNinOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnotherNinOptEnum{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AnotherNinOptEnumDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnotherNinOptEnumDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Timer) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Timer{`, + `Time1:` + fmt.Sprintf("%v", this.Time1) + `,`, + `Time2:` + fmt.Sprintf("%v", this.Time2) + `,`, + `Data:` + fmt.Sprintf("%v", this.Data) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *MyExtendable) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&MyExtendable{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsMap(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OtherExtenable) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OtherExtenable{`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `M:` + strings.Replace(fmt.Sprintf("%v", this.M), "MyExtendable", "MyExtendable", 1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsMap(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `EnumField:` + valueToStringThetest(this.EnumField) + `,`, + `NNM:` + strings.Replace(fmt.Sprintf("%v", this.NNM), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `NM:` + strings.Replace(fmt.Sprintf("%v", this.NM), "NestedDefinition_NestedMessage", "NestedDefinition_NestedMessage", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition_NestedMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition_NestedMessage{`, + `NestedField1:` + valueToStringThetest(this.NestedField1) + `,`, + `NNM:` + strings.Replace(fmt.Sprintf("%v", this.NNM), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition_NestedMessage_NestedNestedMsg{`, + `NestedNestedField1:` + valueToStringThetest(this.NestedNestedField1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedScope) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedScope{`, + `A:` + strings.Replace(fmt.Sprintf("%v", this.A), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `B:` + valueToStringThetest(this.B) + `,`, + `C:` + strings.Replace(fmt.Sprintf("%v", this.C), "NestedDefinition_NestedMessage", "NestedDefinition_NestedMessage", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNativeDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNativeDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + valueToStringThetest(this.Field8) + `,`, + `Field9:` + valueToStringThetest(this.Field9) + `,`, + `Field10:` + valueToStringThetest(this.Field10) + `,`, + `Field11:` + valueToStringThetest(this.Field11) + `,`, + `Field12:` + valueToStringThetest(this.Field12) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomContainer) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomContainer{`, + `CustomStruct:` + strings.Replace(strings.Replace(this.CustomStruct.String(), "NidOptCustom", "NidOptCustom", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNidOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNidOptNative{`, + `FieldA:` + fmt.Sprintf("%v", this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `FieldE:` + fmt.Sprintf("%v", this.FieldE) + `,`, + `FieldF:` + fmt.Sprintf("%v", this.FieldF) + `,`, + `FieldG:` + fmt.Sprintf("%v", this.FieldG) + `,`, + `FieldH:` + fmt.Sprintf("%v", this.FieldH) + `,`, + `FieldI:` + fmt.Sprintf("%v", this.FieldI) + `,`, + `FieldJ:` + fmt.Sprintf("%v", this.FieldJ) + `,`, + `FieldK:` + fmt.Sprintf("%v", this.FieldK) + `,`, + `FieldL:` + fmt.Sprintf("%v", this.FieldL) + `,`, + `FieldM:` + fmt.Sprintf("%v", this.FieldM) + `,`, + `FieldN:` + fmt.Sprintf("%v", this.FieldN) + `,`, + `FieldO:` + fmt.Sprintf("%v", this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinOptNative{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + valueToStringThetest(this.FieldC) + `,`, + `FieldD:` + valueToStringThetest(this.FieldD) + `,`, + `FieldE:` + valueToStringThetest(this.FieldE) + `,`, + `FieldF:` + valueToStringThetest(this.FieldF) + `,`, + `FieldG:` + valueToStringThetest(this.FieldG) + `,`, + `FieldH:` + valueToStringThetest(this.FieldH) + `,`, + `FieldI:` + valueToStringThetest(this.FieldI) + `,`, + `FieldJ:` + valueToStringThetest(this.FieldJ) + `,`, + `FieldK:` + valueToStringThetest(this.FieldK) + `,`, + `FielL:` + valueToStringThetest(this.FielL) + `,`, + `FieldM:` + valueToStringThetest(this.FieldM) + `,`, + `FieldN:` + valueToStringThetest(this.FieldN) + `,`, + `FieldO:` + valueToStringThetest(this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinRepNative{`, + `FieldA:` + fmt.Sprintf("%v", this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `FieldE:` + fmt.Sprintf("%v", this.FieldE) + `,`, + `FieldF:` + fmt.Sprintf("%v", this.FieldF) + `,`, + `FieldG:` + fmt.Sprintf("%v", this.FieldG) + `,`, + `FieldH:` + fmt.Sprintf("%v", this.FieldH) + `,`, + `FieldI:` + fmt.Sprintf("%v", this.FieldI) + `,`, + `FieldJ:` + fmt.Sprintf("%v", this.FieldJ) + `,`, + `FieldK:` + fmt.Sprintf("%v", this.FieldK) + `,`, + `FieldL:` + fmt.Sprintf("%v", this.FieldL) + `,`, + `FieldM:` + fmt.Sprintf("%v", this.FieldM) + `,`, + `FieldN:` + fmt.Sprintf("%v", this.FieldN) + `,`, + `FieldO:` + fmt.Sprintf("%v", this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinStruct{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + strings.Replace(fmt.Sprintf("%v", this.FieldC), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldD:` + strings.Replace(fmt.Sprintf("%v", this.FieldD), "NinOptNative", "NinOptNative", 1) + `,`, + `FieldE:` + valueToStringThetest(this.FieldE) + `,`, + `FieldF:` + valueToStringThetest(this.FieldF) + `,`, + `FieldG:` + strings.Replace(fmt.Sprintf("%v", this.FieldG), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldH:` + valueToStringThetest(this.FieldH) + `,`, + `FieldI:` + valueToStringThetest(this.FieldI) + `,`, + `FieldJ:` + valueToStringThetest(this.FieldJ) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameCustomType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameCustomType{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinEmbeddedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinEmbeddedStructUnion{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldA:` + strings.Replace(fmt.Sprintf("%v", this.FieldA), "NinOptNative", "NinOptNative", 1) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameEnum{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NoExtensionsMap) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NoExtensionsMap{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsBytes(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Unrecognized) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Unrecognized{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithInner) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithInner{`, + `Embedded:` + strings.Replace(fmt.Sprintf("%v", this.Embedded), "UnrecognizedWithInner_Inner", "UnrecognizedWithInner_Inner", 1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithInner_Inner) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithInner_Inner{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithEmbed) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithEmbed{`, + `UnrecognizedWithEmbed_Embedded:` + strings.Replace(strings.Replace(this.UnrecognizedWithEmbed_Embedded.String(), "UnrecognizedWithEmbed_Embedded", "UnrecognizedWithEmbed_Embedded", 1), `&`, ``, 1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithEmbed_Embedded) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithEmbed_Embedded{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func valueToStringThetest(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (this *NinOptNativeUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + if this.Field4 != nil { + return this.Field4 + } + if this.Field5 != nil { + return this.Field5 + } + if this.Field6 != nil { + return this.Field6 + } + if this.Field13 != nil { + return this.Field13 + } + if this.Field14 != nil { + return this.Field14 + } + if this.Field15 != nil { + return this.Field15 + } + return nil +} + +func (this *NinOptNativeUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *float64: + this.Field1 = vt + case *float32: + this.Field2 = vt + case *int32: + this.Field3 = vt + case *int64: + this.Field4 = vt + case *uint32: + this.Field5 = vt + case *uint64: + this.Field6 = vt + case *bool: + this.Field13 = vt + case *string: + this.Field14 = vt + case []byte: + this.Field15 = vt + default: + return false + } + return true +} +func (this *NinOptStructUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + if this.Field4 != nil { + return this.Field4 + } + if this.Field6 != nil { + return this.Field6 + } + if this.Field7 != nil { + return this.Field7 + } + if this.Field13 != nil { + return this.Field13 + } + if this.Field14 != nil { + return this.Field14 + } + if this.Field15 != nil { + return this.Field15 + } + return nil +} + +func (this *NinOptStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *float64: + this.Field1 = vt + case *float32: + this.Field2 = vt + case *NidOptNative: + this.Field3 = vt + case *NinOptNative: + this.Field4 = vt + case *uint64: + this.Field6 = vt + case *int32: + this.Field7 = vt + case *bool: + this.Field13 = vt + case *string: + this.Field14 = vt + case []byte: + this.Field15 = vt + default: + return false + } + return true +} +func (this *NinEmbeddedStructUnion) GetValue() interface{} { + if this.NidOptNative != nil { + return this.NidOptNative + } + if this.Field200 != nil { + return this.Field200 + } + if this.Field210 != nil { + return this.Field210 + } + return nil +} + +func (this *NinEmbeddedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NidOptNative: + this.NidOptNative = vt + case *NinOptNative: + this.Field200 = vt + case *bool: + this.Field210 = vt + default: + return false + } + return true +} +func (this *NinNestedStructUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + return nil +} + +func (this *NinNestedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NinOptNativeUnion: + this.Field1 = vt + case *NinOptStructUnion: + this.Field2 = vt + case *NinEmbeddedStructUnion: + this.Field3 = vt + default: + this.Field1 = new(NinOptNativeUnion) + if set := this.Field1.SetValue(value); set { + return true + } + this.Field1 = nil + this.Field2 = new(NinOptStructUnion) + if set := this.Field2.SetValue(value); set { + return true + } + this.Field2 = nil + this.Field3 = new(NinEmbeddedStructUnion) + if set := this.Field3.SetValue(value); set { + return true + } + this.Field3 = nil + return false + } + return true +} +func (this *Tree) GetValue() interface{} { + if this.Or != nil { + return this.Or + } + if this.And != nil { + return this.And + } + if this.Leaf != nil { + return this.Leaf + } + return nil +} + +func (this *Tree) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *OrBranch: + this.Or = vt + case *AndBranch: + this.And = vt + case *Leaf: + this.Leaf = vt + default: + return false + } + return true +} +func (this *DeepTree) GetValue() interface{} { + if this.Down != nil { + return this.Down + } + if this.And != nil { + return this.And + } + if this.Leaf != nil { + return this.Leaf + } + return nil +} + +func (this *DeepTree) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *ADeepBranch: + this.Down = vt + case *AndDeepBranch: + this.And = vt + case *DeepLeaf: + this.Leaf = vt + default: + return false + } + return true +} +func (this *CustomNameNinEmbeddedStructUnion) GetValue() interface{} { + if this.NidOptNative != nil { + return this.NidOptNative + } + if this.FieldA != nil { + return this.FieldA + } + if this.FieldB != nil { + return this.FieldB + } + return nil +} + +func (this *CustomNameNinEmbeddedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NidOptNative: + this.NidOptNative = vt + case *NinOptNative: + this.FieldA = vt + case *bool: + this.FieldB = vt + default: + return false + } + return true +} +func (m *NidOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field1 = float64(math.Float64frombits(v)) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field2 = float32(math.Float32frombits(v)) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + m.Field3 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field3 |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + m.Field4 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field4 |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + m.Field5 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field5 |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + m.Field6 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field6 |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = int64(v) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + m.Field9 = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + m.Field9 = uint32(data[iNdEx-4]) + m.Field9 |= uint32(data[iNdEx-3]) << 8 + m.Field9 |= uint32(data[iNdEx-2]) << 16 + m.Field9 |= uint32(data[iNdEx-1]) << 24 + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + m.Field10 = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + m.Field10 = int32(data[iNdEx-4]) + m.Field10 |= int32(data[iNdEx-3]) << 8 + m.Field10 |= int32(data[iNdEx-2]) << 16 + m.Field10 |= int32(data[iNdEx-1]) << 24 + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + m.Field11 = 0 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + m.Field11 = uint64(data[iNdEx-8]) + m.Field11 |= uint64(data[iNdEx-7]) << 8 + m.Field11 |= uint64(data[iNdEx-6]) << 16 + m.Field11 |= uint64(data[iNdEx-5]) << 24 + m.Field11 |= uint64(data[iNdEx-4]) << 32 + m.Field11 |= uint64(data[iNdEx-3]) << 40 + m.Field11 |= uint64(data[iNdEx-2]) << 48 + m.Field11 |= uint64(data[iNdEx-1]) << 56 + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + m.Field12 = 0 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + m.Field12 = int64(data[iNdEx-8]) + m.Field12 |= int64(data[iNdEx-7]) << 8 + m.Field12 |= int64(data[iNdEx-6]) << 16 + m.Field12 |= int64(data[iNdEx-5]) << 24 + m.Field12 |= int64(data[iNdEx-4]) << 32 + m.Field12 |= int64(data[iNdEx-3]) << 40 + m.Field12 |= int64(data[iNdEx-2]) << 48 + m.Field12 |= int64(data[iNdEx-1]) << 56 + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = bool(v != 0) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = &v2 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = &v2 + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = &v + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + v2 := int64(v) + m.Field8 = &v2 + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = &v + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = &v + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = &v + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = append(m.Field9, v) + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = append(m.Field10, v) + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = append(m.Field11, v) + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = append(m.Field12, v) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = append(m.Field14, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx)) + copy(m.Field15[len(m.Field15)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = append(m.Field9, v) + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = append(m.Field10, v) + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = append(m.Field11, v) + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = append(m.Field12, v) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = append(m.Field14, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx)) + copy(m.Field15[len(m.Field15)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepPackedNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepPackedNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepPackedNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + } + } else if wireType == 1 { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + case 2: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + } + } else if wireType == 5 { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + case 3: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + case 4: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } + } else if wireType == 0 { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + case 5: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } + } else if wireType == 0 { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + case 6: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + case 7: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + case 8: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + case 9: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = append(m.Field9, v) + } + } else if wireType == 5 { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = append(m.Field9, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + case 10: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = append(m.Field10, v) + } + } else if wireType == 5 { + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = append(m.Field10, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + case 11: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = append(m.Field11, v) + } + } else if wireType == 1 { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = append(m.Field11, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + case 12: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = append(m.Field12, v) + } + } else if wireType == 1 { + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = append(m.Field12, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + case 13: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } + } else if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepPackedNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepPackedNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepPackedNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + } + } else if wireType == 1 { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + case 2: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + } + } else if wireType == 5 { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + case 3: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + case 4: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } + } else if wireType == 0 { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + case 5: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } + } else if wireType == 0 { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + case 6: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + case 7: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + case 8: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + case 9: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = append(m.Field9, v) + } + } else if wireType == 5 { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = append(m.Field9, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + case 10: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = append(m.Field10, v) + } + } else if wireType == 5 { + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = append(m.Field10, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + case 11: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = append(m.Field11, v) + } + } else if wireType == 1 { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = append(m.Field11, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + case 12: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = append(m.Field12, v) + } + } else if wireType == 1 { + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = append(m.Field12, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + case 13: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } + } else if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidOptStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidOptStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidOptStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field1 = float64(math.Float64frombits(v)) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field2 = float32(math.Float32frombits(v)) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field4.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + m.Field6 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field6 |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = v + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field8.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = bool(v != 0) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = &v2 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = &v2 + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field3 == nil { + m.Field3 = &NidOptNative{} + } + if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field4 == nil { + m.Field4 = &NinOptNative{} + } + if err := m.Field4.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field8 == nil { + m.Field8 = &NidOptNative{} + } + if err := m.Field8.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field3 = append(m.Field3, NidOptNative{}) + if err := m.Field3[len(m.Field3)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field4 = append(m.Field4, NinOptNative{}) + if err := m.Field4[len(m.Field4)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field8 = append(m.Field8, NidOptNative{}) + if err := m.Field8[len(m.Field8)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = append(m.Field14, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx)) + copy(m.Field15[len(m.Field15)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field3 = append(m.Field3, &NidOptNative{}) + if err := m.Field3[len(m.Field3)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field4 = append(m.Field4, &NinOptNative{}) + if err := m.Field4[len(m.Field4)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field8 = append(m.Field8, &NidOptNative{}) + if err := m.Field8[len(m.Field8)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = append(m.Field14, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx)) + copy(m.Field15[len(m.Field15)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidEmbeddedStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidEmbeddedStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidEmbeddedStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NidOptNative == nil { + m.NidOptNative = &NidOptNative{} + } + if err := m.NidOptNative.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field200", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field200.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 210: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field210", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field210 = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinEmbeddedStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinEmbeddedStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinEmbeddedStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NidOptNative == nil { + m.NidOptNative = &NidOptNative{} + } + if err := m.NidOptNative.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field200", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field200 == nil { + m.Field200 = &NidOptNative{} + } + if err := m.Field200.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 210: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field210", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field210 = &b + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidNestedStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidNestedStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidNestedStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field1.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field2 = append(m.Field2, NidRepStruct{}) + if err := m.Field2[len(m.Field2)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinNestedStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinNestedStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinNestedStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field1 == nil { + m.Field1 = &NinOptStruct{} + } + if err := m.Field1.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field2 = append(m.Field2, &NinRepStruct{}) + if err := m.Field2[len(m.Field2)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidOptCustom) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidOptCustom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidOptCustom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Id.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Value.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomDash) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomDash: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomDash: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom_dash_type.Bytes + m.Value = &v + if err := m.Value.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptCustom) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptCustom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptCustom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.Id = &v + if err := m.Id.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.Value = &v + if err := m.Value.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepCustom) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepCustom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepCustom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.Id = append(m.Id, v) + if err := m.Id[len(m.Id)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.Value = append(m.Value, v) + if err := m.Value[len(m.Value)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepCustom) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepCustom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepCustom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.Id = append(m.Id, v) + if err := m.Id[len(m.Id)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.Value = append(m.Value, v) + if err := m.Value[len(m.Value)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptNativeUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptNativeUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptNativeUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = &v2 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = &v2 + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = &v + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptStructUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptStructUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptStructUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = &v2 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = &v2 + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field3 == nil { + m.Field3 = &NidOptNative{} + } + if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field4 == nil { + m.Field4 = &NinOptNative{} + } + if err := m.Field4.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinEmbeddedStructUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinEmbeddedStructUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinEmbeddedStructUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NidOptNative == nil { + m.NidOptNative = &NidOptNative{} + } + if err := m.NidOptNative.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field200", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field200 == nil { + m.Field200 = &NinOptNative{} + } + if err := m.Field200.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 210: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field210", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field210 = &b + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinNestedStructUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinNestedStructUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinNestedStructUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field1 == nil { + m.Field1 = &NinOptNativeUnion{} + } + if err := m.Field1.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field2 == nil { + m.Field2 = &NinOptStructUnion{} + } + if err := m.Field2.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field3 == nil { + m.Field3 = &NinEmbeddedStructUnion{} + } + if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Tree) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Tree: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Tree: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Or", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Or == nil { + m.Or = &OrBranch{} + } + if err := m.Or.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field And", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.And == nil { + m.And = &AndBranch{} + } + if err := m.And.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Leaf", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Leaf == nil { + m.Leaf = &Leaf{} + } + if err := m.Leaf.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OrBranch) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OrBranch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OrBranch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Left.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Right.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AndBranch) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AndBranch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AndBranch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Left.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Right.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Leaf) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Leaf: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Leaf: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + m.Value = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Value |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StrValue", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StrValue = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DeepTree) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DeepTree: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeepTree: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Down", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Down == nil { + m.Down = &ADeepBranch{} + } + if err := m.Down.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field And", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.And == nil { + m.And = &AndDeepBranch{} + } + if err := m.And.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Leaf", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Leaf == nil { + m.Leaf = &DeepLeaf{} + } + if err := m.Leaf.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ADeepBranch) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ADeepBranch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ADeepBranch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Down", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Down.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AndDeepBranch) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AndDeepBranch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AndDeepBranch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Left.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Right.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DeepLeaf) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DeepLeaf: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeepLeaf: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tree", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Tree.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Nil) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Nil: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Nil: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidOptEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidOptEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidOptEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + m.Field1 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field1 |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = append(m.Field1, v) + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = append(m.Field1, v) + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptEnumDefault) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptEnumDefault: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptEnumDefault: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnotherNinOptEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnotherNinOptEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnotherNinOptEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v AnotherTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (AnotherTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnotherNinOptEnumDefault) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnotherNinOptEnumDefault: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnotherNinOptEnumDefault: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v AnotherTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (AnotherTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Timer) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Timer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Timer: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Time1", wireType) + } + m.Time1 = 0 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + m.Time1 = int64(data[iNdEx-8]) + m.Time1 |= int64(data[iNdEx-7]) << 8 + m.Time1 |= int64(data[iNdEx-6]) << 16 + m.Time1 |= int64(data[iNdEx-5]) << 24 + m.Time1 |= int64(data[iNdEx-4]) << 32 + m.Time1 |= int64(data[iNdEx-3]) << 40 + m.Time1 |= int64(data[iNdEx-2]) << 48 + m.Time1 |= int64(data[iNdEx-1]) << 56 + case 2: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Time2", wireType) + } + m.Time2 = 0 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + m.Time2 = int64(data[iNdEx-8]) + m.Time2 |= int64(data[iNdEx-7]) << 8 + m.Time2 |= int64(data[iNdEx-6]) << 16 + m.Time2 |= int64(data[iNdEx-5]) << 24 + m.Time2 |= int64(data[iNdEx-4]) << 32 + m.Time2 |= int64(data[iNdEx-3]) << 40 + m.Time2 |= int64(data[iNdEx-2]) << 48 + m.Time2 |= int64(data[iNdEx-1]) << 56 + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MyExtendable) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MyExtendable: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MyExtendable: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + if (fieldNum >= 100) && (fieldNum < 200) { + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + iNdEx -= sizeOfWire + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]github_com_gogo_protobuf_proto.Extension) + } + m.XXX_extensions[int32(fieldNum)] = github_com_gogo_protobuf_proto.NewExtension(data[iNdEx : iNdEx+skippy]) + iNdEx += skippy + } else { + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OtherExtenable) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OtherExtenable: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OtherExtenable: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field2 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = &v + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field M", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.M == nil { + m.M = &MyExtendable{} + } + if err := m.M.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + if ((fieldNum >= 14) && (fieldNum < 17)) || ((fieldNum >= 10) && (fieldNum < 13)) { + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + iNdEx -= sizeOfWire + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]github_com_gogo_protobuf_proto.Extension) + } + m.XXX_extensions[int32(fieldNum)] = github_com_gogo_protobuf_proto.NewExtension(data[iNdEx : iNdEx+skippy]) + iNdEx += skippy + } else { + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NestedDefinition) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NestedDefinition: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NestedDefinition: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EnumField", wireType) + } + var v NestedDefinition_NestedEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (NestedDefinition_NestedEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.EnumField = &v + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NNM", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NNM == nil { + m.NNM = &NestedDefinition_NestedMessage_NestedNestedMsg{} + } + if err := m.NNM.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NM", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NM == nil { + m.NM = &NestedDefinition_NestedMessage{} + } + if err := m.NM.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NestedDefinition_NestedMessage) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NestedMessage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NestedMessage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field NestedField1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.NestedField1 = &v + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NNM", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NNM == nil { + m.NNM = &NestedDefinition_NestedMessage_NestedNestedMsg{} + } + if err := m.NNM.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NestedNestedMsg: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NestedNestedMsg: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NestedNestedField1", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.NestedNestedField1 = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NestedScope) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NestedScope: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NestedScope: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.A == nil { + m.A = &NestedDefinition_NestedMessage_NestedNestedMsg{} + } + if err := m.A.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var v NestedDefinition_NestedEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (NestedDefinition_NestedEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.B = &v + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field C", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.C == nil { + m.C = &NestedDefinition_NestedMessage{} + } + if err := m.C.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptNativeDefault) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptNativeDefault: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptNativeDefault: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = &v2 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = &v2 + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = &v + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + v2 := int64(v) + m.Field8 = &v2 + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = &v + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = &v + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = &v + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomContainer) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomContainer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomContainer: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CustomStruct", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.CustomStruct.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNidOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNidOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNidOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.FieldA = float64(math.Float64frombits(v)) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.FieldB = float32(math.Float32frombits(v)) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + m.FieldC = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.FieldC |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + m.FieldD = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.FieldD |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) + } + m.FieldE = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.FieldE |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) + } + m.FieldF = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.FieldF |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.FieldG = v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.FieldH = int64(v) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType) + } + m.FieldI = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + m.FieldI = uint32(data[iNdEx-4]) + m.FieldI |= uint32(data[iNdEx-3]) << 8 + m.FieldI |= uint32(data[iNdEx-2]) << 16 + m.FieldI |= uint32(data[iNdEx-1]) << 24 + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType) + } + m.FieldJ = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + m.FieldJ = int32(data[iNdEx-4]) + m.FieldJ |= int32(data[iNdEx-3]) << 8 + m.FieldJ |= int32(data[iNdEx-2]) << 16 + m.FieldJ |= int32(data[iNdEx-1]) << 24 + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldK", wireType) + } + m.FieldK = 0 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + m.FieldK = uint64(data[iNdEx-8]) + m.FieldK |= uint64(data[iNdEx-7]) << 8 + m.FieldK |= uint64(data[iNdEx-6]) << 16 + m.FieldK |= uint64(data[iNdEx-5]) << 24 + m.FieldK |= uint64(data[iNdEx-4]) << 32 + m.FieldK |= uint64(data[iNdEx-3]) << 40 + m.FieldK |= uint64(data[iNdEx-2]) << 48 + m.FieldK |= uint64(data[iNdEx-1]) << 56 + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldL", wireType) + } + m.FieldL = 0 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + m.FieldL = int64(data[iNdEx-8]) + m.FieldL |= int64(data[iNdEx-7]) << 8 + m.FieldL |= int64(data[iNdEx-6]) << 16 + m.FieldL |= int64(data[iNdEx-5]) << 24 + m.FieldL |= int64(data[iNdEx-4]) << 32 + m.FieldL |= int64(data[iNdEx-3]) << 40 + m.FieldL |= int64(data[iNdEx-2]) << 48 + m.FieldL |= int64(data[iNdEx-1]) << 56 + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldM", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldM = bool(v != 0) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldN", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldN = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldO", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldO = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNinOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNinOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNinOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.FieldA = &v2 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.FieldB = &v2 + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldC = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldD = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldE = &v + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldF = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.FieldG = &v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + v2 := int64(v) + m.FieldH = &v2 + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.FieldI = &v + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.FieldJ = &v + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldK", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.FieldK = &v + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FielL", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.FielL = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldM", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.FieldM = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldN", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.FieldN = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldO", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldO = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNinRepNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNinRepNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNinRepNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.FieldA = append(m.FieldA, v2) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.FieldB = append(m.FieldB, v2) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldC = append(m.FieldC, v) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldD = append(m.FieldD, v) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldE = append(m.FieldE, v) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldF = append(m.FieldF, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.FieldG = append(m.FieldG, v) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.FieldH = append(m.FieldH, int64(v)) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.FieldI = append(m.FieldI, v) + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.FieldJ = append(m.FieldJ, v) + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldK", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.FieldK = append(m.FieldK, v) + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldL", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.FieldL = append(m.FieldL, v) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldM", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldM = append(m.FieldM, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldN", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldN = append(m.FieldN, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldO", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldO = append(m.FieldO, make([]byte, postIndex-iNdEx)) + copy(m.FieldO[len(m.FieldO)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNinStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNinStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNinStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.FieldA = &v2 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.FieldB = &v2 + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FieldC == nil { + m.FieldC = &NidOptNative{} + } + if err := m.FieldC.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldD = append(m.FieldD, &NinOptNative{}) + if err := m.FieldD[len(m.FieldD)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldE = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.FieldF = &v + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FieldG == nil { + m.FieldG = &NidOptNative{} + } + if err := m.FieldG.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.FieldH = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.FieldI = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldJ = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameCustomType) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameCustomType: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameCustomType: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.FieldA = &v + if err := m.FieldA.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.FieldB = &v + if err := m.FieldB.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.FieldC = append(m.FieldC, v) + if err := m.FieldC[len(m.FieldC)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.FieldD = append(m.FieldD, v) + if err := m.FieldD[len(m.FieldD)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNinEmbeddedStructUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNinEmbeddedStructUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNinEmbeddedStructUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NidOptNative == nil { + m.NidOptNative = &NidOptNative{} + } + if err := m.NidOptNative.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FieldA == nil { + m.FieldA = &NinOptNative{} + } + if err := m.FieldA.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 210: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.FieldB = &b + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldA = &v + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldB = append(m.FieldB, v) + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NoExtensionsMap) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NoExtensionsMap: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NoExtensionsMap: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + if (fieldNum >= 100) && (fieldNum < 200) { + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + iNdEx -= sizeOfWire + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_extensions = append(m.XXX_extensions, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } else { + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Unrecognized) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Unrecognized: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Unrecognized: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field1 = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnrecognizedWithInner) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UnrecognizedWithInner: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UnrecognizedWithInner: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Embedded", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Embedded = append(m.Embedded, &UnrecognizedWithInner_Inner{}) + if err := m.Embedded[len(m.Embedded)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field2 = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnrecognizedWithInner_Inner) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Inner: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Inner: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnrecognizedWithEmbed) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UnrecognizedWithEmbed: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UnrecognizedWithEmbed: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnrecognizedWithEmbed_Embedded", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.UnrecognizedWithEmbed_Embedded.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetest + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field2 = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnrecognizedWithEmbed_Embedded) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Embedded: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Embedded: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetest + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetest(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetest + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipThetest(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowThetest + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowThetest + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowThetest + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthThetest + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowThetest + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipThetest(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthThetest = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowThetest = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unmarshaler/thetest.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unmarshaler/thetest.proto new file mode 100644 index 0000000000000000000000000000000000000000..6ff32bfdf2deab9b3203c43359985bf85d86dadc --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unmarshaler/thetest.proto @@ -0,0 +1,584 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package test; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message NidOptNative { + optional double Field1 = 1 [(gogoproto.nullable) = false]; + optional float Field2 = 2 [(gogoproto.nullable) = false]; + optional int32 Field3 = 3 [(gogoproto.nullable) = false]; + optional int64 Field4 = 4 [(gogoproto.nullable) = false]; + optional uint32 Field5 = 5 [(gogoproto.nullable) = false]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false]; + optional sint64 Field8 = 8 [(gogoproto.nullable) = false]; + optional fixed32 Field9 = 9 [(gogoproto.nullable) = false]; + optional sfixed32 Field10 = 10 [(gogoproto.nullable) = false]; + optional fixed64 Field11 = 11 [(gogoproto.nullable) = false]; + optional sfixed64 Field12 = 12 [(gogoproto.nullable) = false]; + optional bool Field13 = 13 [(gogoproto.nullable) = false]; + optional string Field14 = 14 [(gogoproto.nullable) = false]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinOptNative { + optional double Field1 = 1; + optional float Field2 = 2; + optional int32 Field3 = 3; + optional int64 Field4 = 4; + optional uint32 Field5 = 5; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional sint64 Field8 = 8; + optional fixed32 Field9 = 9; + optional sfixed32 Field10 = 10; + optional fixed64 Field11 = 11; + optional sfixed64 Field12 = 12; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NidRepNative { + repeated double Field1 = 1 [(gogoproto.nullable) = false]; + repeated float Field2 = 2 [(gogoproto.nullable) = false]; + repeated int32 Field3 = 3 [(gogoproto.nullable) = false]; + repeated int64 Field4 = 4 [(gogoproto.nullable) = false]; + repeated uint32 Field5 = 5 [(gogoproto.nullable) = false]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false]; + repeated sint64 Field8 = 8 [(gogoproto.nullable) = false]; + repeated fixed32 Field9 = 9 [(gogoproto.nullable) = false]; + repeated sfixed32 Field10 = 10 [(gogoproto.nullable) = false]; + repeated fixed64 Field11 = 11 [(gogoproto.nullable) = false]; + repeated sfixed64 Field12 = 12 [(gogoproto.nullable) = false]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false]; + repeated string Field14 = 14 [(gogoproto.nullable) = false]; + repeated bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinRepNative { + repeated double Field1 = 1; + repeated float Field2 = 2; + repeated int32 Field3 = 3; + repeated int64 Field4 = 4; + repeated uint32 Field5 = 5; + repeated uint64 Field6 = 6; + repeated sint32 Field7 = 7; + repeated sint64 Field8 = 8; + repeated fixed32 Field9 = 9; + repeated sfixed32 Field10 = 10; + repeated fixed64 Field11 = 11; + repeated sfixed64 Field12 = 12; + repeated bool Field13 = 13; + repeated string Field14 = 14; + repeated bytes Field15 = 15; +} + +message NidRepPackedNative { + repeated double Field1 = 1 [(gogoproto.nullable) = false, packed = true]; + repeated float Field2 = 2 [(gogoproto.nullable) = false, packed = true]; + repeated int32 Field3 = 3 [(gogoproto.nullable) = false, packed = true]; + repeated int64 Field4 = 4 [(gogoproto.nullable) = false, packed = true]; + repeated uint32 Field5 = 5 [(gogoproto.nullable) = false, packed = true]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false, packed = true]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false, packed = true]; + repeated sint64 Field8 = 8 [(gogoproto.nullable) = false, packed = true]; + repeated fixed32 Field9 = 9 [(gogoproto.nullable) = false, packed = true]; + repeated sfixed32 Field10 = 10 [(gogoproto.nullable) = false, packed = true]; + repeated fixed64 Field11 = 11 [(gogoproto.nullable) = false, packed = true]; + repeated sfixed64 Field12 = 12 [(gogoproto.nullable) = false, packed = true]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false, packed = true]; +} + +message NinRepPackedNative { + repeated double Field1 = 1 [packed = true]; + repeated float Field2 = 2 [packed = true]; + repeated int32 Field3 = 3 [packed = true]; + repeated int64 Field4 = 4 [packed = true]; + repeated uint32 Field5 = 5 [packed = true]; + repeated uint64 Field6 = 6 [packed = true]; + repeated sint32 Field7 = 7 [packed = true]; + repeated sint64 Field8 = 8 [packed = true]; + repeated fixed32 Field9 = 9 [packed = true]; + repeated sfixed32 Field10 = 10 [packed = true]; + repeated fixed64 Field11 = 11 [packed = true]; + repeated sfixed64 Field12 = 12 [packed = true]; + repeated bool Field13 = 13 [packed = true]; +} + +message NidOptStruct { + optional double Field1 = 1 [(gogoproto.nullable) = false]; + optional float Field2 = 2 [(gogoproto.nullable) = false]; + optional NidOptNative Field3 = 3 [(gogoproto.nullable) = false]; + optional NinOptNative Field4 = 4 [(gogoproto.nullable) = false]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false]; + optional NidOptNative Field8 = 8 [(gogoproto.nullable) = false]; + optional bool Field13 = 13 [(gogoproto.nullable) = false]; + optional string Field14 = 14 [(gogoproto.nullable) = false]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinOptStruct { + optional double Field1 = 1; + optional float Field2 = 2; + optional NidOptNative Field3 = 3; + optional NinOptNative Field4 = 4; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional NidOptNative Field8 = 8; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NidRepStruct { + repeated double Field1 = 1 [(gogoproto.nullable) = false]; + repeated float Field2 = 2 [(gogoproto.nullable) = false]; + repeated NidOptNative Field3 = 3 [(gogoproto.nullable) = false]; + repeated NinOptNative Field4 = 4 [(gogoproto.nullable) = false]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false]; + repeated NidOptNative Field8 = 8 [(gogoproto.nullable) = false]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false]; + repeated string Field14 = 14 [(gogoproto.nullable) = false]; + repeated bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinRepStruct { + repeated double Field1 = 1; + repeated float Field2 = 2; + repeated NidOptNative Field3 = 3; + repeated NinOptNative Field4 = 4; + repeated uint64 Field6 = 6; + repeated sint32 Field7 = 7; + repeated NidOptNative Field8 = 8; + repeated bool Field13 = 13; + repeated string Field14 = 14; + repeated bytes Field15 = 15; +} + +message NidEmbeddedStruct { + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NidOptNative Field200 = 200 [(gogoproto.nullable) = false]; + optional bool Field210 = 210 [(gogoproto.nullable) = false]; +} + +message NinEmbeddedStruct { + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NidOptNative Field200 = 200; + optional bool Field210 = 210; +} + +message NidNestedStruct { + optional NidOptStruct Field1 = 1 [(gogoproto.nullable) = false]; + repeated NidRepStruct Field2 = 2 [(gogoproto.nullable) = false]; +} + +message NinNestedStruct { + optional NinOptStruct Field1 = 1; + repeated NinRepStruct Field2 = 2; +} + +message NidOptCustom { + optional bytes Id = 1 [(gogoproto.customtype) = "Uuid", (gogoproto.nullable) = false]; + optional bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; +} + +message CustomDash { + optional bytes Value = 1 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom-dash-type.Bytes"]; +} + +message NinOptCustom { + optional bytes Id = 1 [(gogoproto.customtype) = "Uuid"]; + optional bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message NidRepCustom { + repeated bytes Id = 1 [(gogoproto.customtype) = "Uuid", (gogoproto.nullable) = false]; + repeated bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; +} + +message NinRepCustom { + repeated bytes Id = 1 [(gogoproto.customtype) = "Uuid"]; + repeated bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message NinOptNativeUnion { + option (gogoproto.onlyone) = true; + optional double Field1 = 1; + optional float Field2 = 2; + optional int32 Field3 = 3; + optional int64 Field4 = 4; + optional uint32 Field5 = 5; + optional uint64 Field6 = 6; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NinOptStructUnion { + option (gogoproto.onlyone) = true; + optional double Field1 = 1; + optional float Field2 = 2; + optional NidOptNative Field3 = 3; + optional NinOptNative Field4 = 4; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NinEmbeddedStructUnion { + option (gogoproto.onlyone) = true; + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NinOptNative Field200 = 200; + optional bool Field210 = 210; +} + +message NinNestedStructUnion { + option (gogoproto.onlyone) = true; + optional NinOptNativeUnion Field1 = 1; + optional NinOptStructUnion Field2 = 2; + optional NinEmbeddedStructUnion Field3 = 3; +} + +message Tree { + option (gogoproto.onlyone) = true; + optional OrBranch Or = 1; + optional AndBranch And = 2; + optional Leaf Leaf = 3; +} + +message OrBranch { + optional Tree Left = 1 [(gogoproto.nullable) = false]; + optional Tree Right = 2 [(gogoproto.nullable) = false]; +} + +message AndBranch { + optional Tree Left = 1 [(gogoproto.nullable) = false]; + optional Tree Right = 2 [(gogoproto.nullable) = false]; +} + +message Leaf { + optional int64 Value = 1 [(gogoproto.nullable) = false]; + optional string StrValue = 2 [(gogoproto.nullable) = false]; +} + +message DeepTree { + option (gogoproto.onlyone) = true; + optional ADeepBranch Down = 1; + optional AndDeepBranch And = 2; + optional DeepLeaf Leaf = 3; +} + +message ADeepBranch { + optional DeepTree Down = 2 [(gogoproto.nullable) = false]; +} + +message AndDeepBranch { + optional DeepTree Left = 1 [(gogoproto.nullable) = false]; + optional DeepTree Right = 2 [(gogoproto.nullable) = false]; +} + +message DeepLeaf { + optional Tree Tree = 1 [(gogoproto.nullable) = false]; +} + +message Nil { + +} + +enum TheTestEnum { + A = 0; + B = 1; + C = 2; +} + +message NidOptEnum { + optional TheTestEnum Field1 = 1 [(gogoproto.nullable) = false]; +} + +message NinOptEnum { + optional TheTestEnum Field1 = 1; +} + +message NidRepEnum { + repeated TheTestEnum Field1 = 1 [(gogoproto.nullable) = false]; +} + +message NinRepEnum { + repeated TheTestEnum Field1 = 1; +} + +message NinOptEnumDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional TheTestEnum Field1 = 1 [default=C]; +} + +enum AnotherTestEnum { + option (gogoproto.goproto_enum_prefix) = false; + D = 10; + E = 11; +} + +message AnotherNinOptEnum { + optional AnotherTestEnum Field1 = 1; +} + +message AnotherNinOptEnumDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional AnotherTestEnum Field1 = 1 [default=E]; +} + +message Timer { + optional sfixed64 Time1 = 1 [(gogoproto.nullable) = false]; + optional sfixed64 Time2 = 2 [(gogoproto.nullable) = false]; + optional bytes Data = 3 [(gogoproto.nullable) = false]; +} + +message MyExtendable { + option (gogoproto.face) = false; + optional int64 Field1 = 1; + extensions 100 to 199; +} + +extend MyExtendable { + optional double FieldA = 100; + optional NinOptNative FieldB = 101; + optional NinEmbeddedStruct FieldC = 102; +} + +message OtherExtenable { + option (gogoproto.face) = false; + optional int64 Field2 = 2; + extensions 14 to 16; + optional int64 Field13 = 13; + extensions 10 to 12; + optional MyExtendable M = 1; +} + +message NestedDefinition { + optional int64 Field1 = 1; + message NestedMessage { + optional fixed64 NestedField1 = 1; + optional NestedNestedMsg NNM = 2; + message NestedNestedMsg { + optional string NestedNestedField1 = 10; + } + } + enum NestedEnum { + TYPE_NESTED = 1; + } + optional NestedEnum EnumField = 2; + optional NestedMessage.NestedNestedMsg NNM = 3; + optional NestedMessage NM = 4; +} + +message NestedScope { + optional NestedDefinition.NestedMessage.NestedNestedMsg A = 1; + optional NestedDefinition.NestedEnum B = 2; + optional NestedDefinition.NestedMessage C = 3; +} + +message NinOptNativeDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional double Field1 = 1 [default = 1234.1234]; + optional float Field2 = 2 [default = 1234.1234]; + optional int32 Field3 = 3 [default = 1234]; + optional int64 Field4 = 4 [default = 1234]; + optional uint32 Field5 = 5 [default = 1234]; + optional uint64 Field6 = 6 [default = 1234]; + optional sint32 Field7 = 7 [default = 1234]; + optional sint64 Field8 = 8 [default = 1234]; + optional fixed32 Field9 = 9 [default = 1234]; + optional sfixed32 Field10 = 10 [default = 1234]; + optional fixed64 Field11 = 11 [default = 1234]; + optional sfixed64 Field12 = 12 [default = 1234]; + optional bool Field13 = 13 [default = true]; + optional string Field14 = 14 [default = "1234"]; + optional bytes Field15 = 15; +} + +message CustomContainer { + optional NidOptCustom CustomStruct = 1 [(gogoproto.nullable) = false]; +} + +message CustomNameNidOptNative { + optional double Field1 = 1 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldB"]; + optional int32 Field3 = 3 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldC"]; + optional int64 Field4 = 4 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldD"]; + optional uint32 Field5 = 5 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldE"]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldF"]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldG"]; + optional sint64 Field8 = 8 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldH"]; + optional fixed32 Field9 = 9 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldI"]; + optional sfixed32 Field10 = 10 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldJ"]; + optional fixed64 Field11 = 11 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldK"]; + optional sfixed64 Field12 = 12 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldL"]; + optional bool Field13 = 13 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldM"]; + optional string Field14 = 14 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldN"]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinOptNative { + optional double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + optional int32 Field3 = 3 [(gogoproto.customname) = "FieldC"]; + optional int64 Field4 = 4 [(gogoproto.customname) = "FieldD"]; + optional uint32 Field5 = 5 [(gogoproto.customname) = "FieldE"]; + optional uint64 Field6 = 6 [(gogoproto.customname) = "FieldF"]; + optional sint32 Field7 = 7 [(gogoproto.customname) = "FieldG"]; + optional sint64 Field8 = 8 [(gogoproto.customname) = "FieldH"]; + optional fixed32 Field9 = 9 [(gogoproto.customname) = "FieldI"]; + optional sfixed32 Field10 = 10 [(gogoproto.customname) = "FieldJ"]; + optional fixed64 Field11 = 11 [(gogoproto.customname) = "FieldK"]; + optional sfixed64 Field12 = 12 [(gogoproto.customname) = "FielL"]; + optional bool Field13 = 13 [(gogoproto.customname) = "FieldM"]; + optional string Field14 = 14 [(gogoproto.customname) = "FieldN"]; + optional bytes Field15 = 15 [(gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinRepNative { + repeated double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + repeated float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + repeated int32 Field3 = 3 [(gogoproto.customname) = "FieldC"]; + repeated int64 Field4 = 4 [(gogoproto.customname) = "FieldD"]; + repeated uint32 Field5 = 5 [(gogoproto.customname) = "FieldE"]; + repeated uint64 Field6 = 6 [(gogoproto.customname) = "FieldF"]; + repeated sint32 Field7 = 7 [(gogoproto.customname) = "FieldG"]; + repeated sint64 Field8 = 8 [(gogoproto.customname) = "FieldH"]; + repeated fixed32 Field9 = 9 [(gogoproto.customname) = "FieldI"]; + repeated sfixed32 Field10 = 10 [(gogoproto.customname) = "FieldJ"]; + repeated fixed64 Field11 = 11 [(gogoproto.customname) = "FieldK"]; + repeated sfixed64 Field12 = 12 [(gogoproto.customname) = "FieldL"]; + repeated bool Field13 = 13 [(gogoproto.customname) = "FieldM"]; + repeated string Field14 = 14 [(gogoproto.customname) = "FieldN"]; + repeated bytes Field15 = 15 [(gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinStruct { + optional double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + optional NidOptNative Field3 = 3 [(gogoproto.customname) = "FieldC"]; + repeated NinOptNative Field4 = 4 [(gogoproto.customname) = "FieldD"]; + optional uint64 Field6 = 6 [(gogoproto.customname) = "FieldE"]; + optional sint32 Field7 = 7 [(gogoproto.customname) = "FieldF"]; + optional NidOptNative Field8 = 8 [(gogoproto.customname) = "FieldG"]; + optional bool Field13 = 13 [(gogoproto.customname) = "FieldH"]; + optional string Field14 = 14 [(gogoproto.customname) = "FieldI"]; + optional bytes Field15 = 15 [(gogoproto.customname) = "FieldJ"]; +} + +message CustomNameCustomType { + optional bytes Id = 1 [(gogoproto.customname) = "FieldA", (gogoproto.customtype) = "Uuid"]; + optional bytes Value = 2 [(gogoproto.customname) = "FieldB", (gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; + repeated bytes Ids = 3 [(gogoproto.customname) = "FieldC", (gogoproto.customtype) = "Uuid"]; + repeated bytes Values = 4 [(gogoproto.customname) = "FieldD", (gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message CustomNameNinEmbeddedStructUnion { + option (gogoproto.onlyone) = true; + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NinOptNative Field200 = 200 [(gogoproto.customname) = "FieldA"]; + optional bool Field210 = 210 [(gogoproto.customname) = "FieldB"]; +} + +message CustomNameEnum { + optional TheTestEnum Field1 = 1 [(gogoproto.customname) = "FieldA"]; + repeated TheTestEnum Field2 = 2 [(gogoproto.customname) = "FieldB"]; +} + +message NoExtensionsMap { + option (gogoproto.face) = false; + option (gogoproto.goproto_extensions_map) = false; + optional int64 Field1 = 1; + extensions 100 to 199; +} + +extend NoExtensionsMap { + optional double FieldA1 = 100; + optional NinOptNative FieldB1 = 101; + optional NinEmbeddedStruct FieldC1 = 102; +} + +message Unrecognized { + option (gogoproto.goproto_unrecognized) = false; + optional string Field1 = 1; +} + +message UnrecognizedWithInner { + message Inner { + option (gogoproto.goproto_unrecognized) = false; + optional uint32 Field1 = 1; + } + + repeated Inner embedded = 1; + optional string Field2 = 2; +} + +message UnrecognizedWithEmbed { + message Embedded { + option (gogoproto.goproto_unrecognized) = false; + optional uint32 Field1 = 1; + } + + optional Embedded embedded = 1 [(gogoproto.embed) = true, (gogoproto.nullable) = false]; + optional string Field2 = 2; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unmarshaler/thetestpb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unmarshaler/thetestpb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..08a67692cca4d3a530755bc299d91f673ff5570c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unmarshaler/thetestpb_test.go @@ -0,0 +1,12939 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unmarshaler/thetest.proto +// DO NOT EDIT! + +/* +Package test is a generated protocol buffer package. + +It is generated from these files: + combos/unmarshaler/thetest.proto + +It has these top-level messages: + NidOptNative + NinOptNative + NidRepNative + NinRepNative + NidRepPackedNative + NinRepPackedNative + NidOptStruct + NinOptStruct + NidRepStruct + NinRepStruct + NidEmbeddedStruct + NinEmbeddedStruct + NidNestedStruct + NinNestedStruct + NidOptCustom + CustomDash + NinOptCustom + NidRepCustom + NinRepCustom + NinOptNativeUnion + NinOptStructUnion + NinEmbeddedStructUnion + NinNestedStructUnion + Tree + OrBranch + AndBranch + Leaf + DeepTree + ADeepBranch + AndDeepBranch + DeepLeaf + Nil + NidOptEnum + NinOptEnum + NidRepEnum + NinRepEnum + NinOptEnumDefault + AnotherNinOptEnum + AnotherNinOptEnumDefault + Timer + MyExtendable + OtherExtenable + NestedDefinition + NestedScope + NinOptNativeDefault + CustomContainer + CustomNameNidOptNative + CustomNameNinOptNative + CustomNameNinRepNative + CustomNameNinStruct + CustomNameCustomType + CustomNameNinEmbeddedStructUnion + CustomNameEnum + NoExtensionsMap + Unrecognized + UnrecognizedWithInner + UnrecognizedWithEmbed +*/ +package test + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestNidOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepPackedNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidRepPackedNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepPackedNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepPackedNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepPackedNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepPackedNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepPackedNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinRepPackedNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepPackedNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepPackedNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepPackedNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepPackedNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidOptStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidRepStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinRepStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidEmbeddedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidEmbeddedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidEmbeddedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidEmbeddedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidEmbeddedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidEmbeddedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinEmbeddedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinEmbeddedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinEmbeddedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidNestedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidNestedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidNestedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidNestedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidNestedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidNestedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinNestedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinNestedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinNestedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidOptCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomDashProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomDashProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomDash, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomDash(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomDashProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomDash(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomDash{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidRepCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinRepCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptNativeUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNativeUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNativeUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinEmbeddedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinEmbeddedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinNestedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinNestedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinNestedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinNestedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestTreeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkTreeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Tree, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkTreeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTree(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Tree{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestOrBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkOrBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OrBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedOrBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkOrBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOrBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &OrBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAndBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAndBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAndBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AndBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestLeafProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkLeafProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Leaf, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkLeafProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLeaf(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Leaf{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepTreeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkDeepTreeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepTree, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedDeepTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkDeepTreeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepTree(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &DeepTree{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestADeepBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkADeepBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*ADeepBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedADeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkADeepBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedADeepBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &ADeepBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndDeepBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAndDeepBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndDeepBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAndDeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAndDeepBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndDeepBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AndDeepBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepLeafProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkDeepLeafProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepLeaf, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedDeepLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkDeepLeafProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepLeaf(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &DeepLeaf{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNilProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNilProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nil, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNil(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNilProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNil(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Nil{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidRepEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinRepEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptEnumDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnumDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptEnumDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnumDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptEnumDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAnotherNinOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAnotherNinOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AnotherNinOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAnotherNinOptEnumDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnumDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAnotherNinOptEnumDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnumDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AnotherNinOptEnumDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestTimerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkTimerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Timer, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedTimer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkTimerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTimer(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Timer{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMyExtendableProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkMyExtendableProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MyExtendable, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMyExtendable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMyExtendableProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMyExtendable(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &MyExtendable{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestOtherExtenableProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkOtherExtenableProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OtherExtenable, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedOtherExtenable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkOtherExtenableProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOtherExtenable(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &OtherExtenable{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinitionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNestedDefinitionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinitionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessageProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNestedDefinition_NestedMessageProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinition_NestedMessageProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition_NestedMessage{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedScopeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNestedScopeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedScope, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedScope(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedScopeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedScope(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedScope{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptNativeDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNativeDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNativeDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomContainerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomContainerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomContainer, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomContainer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomContainerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomContainer(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomContainer{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNidOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameNidOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNidOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNidOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNidOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNidOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameNinOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameNinRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameNinStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameCustomTypeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameCustomTypeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameCustomType, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameCustomType(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameCustomTypeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameCustomType(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameCustomType{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinEmbeddedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameNinEmbeddedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinEmbeddedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinEmbeddedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNoExtensionsMapProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNoExtensionsMapProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NoExtensionsMap, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNoExtensionsMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNoExtensionsMapProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNoExtensionsMap(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NoExtensionsMap{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkUnrecognizedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Unrecognized, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognized(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognized(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Unrecognized{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInnerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkUnrecognizedWithInnerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithInnerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithInner{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInner_InnerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkUnrecognizedWithInner_InnerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner_Inner, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithInner_InnerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner_Inner(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithInner_Inner{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkUnrecognizedWithEmbedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithEmbedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithEmbed{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbed_EmbeddedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed_Embedded, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithEmbed_Embedded{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepPackedNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepPackedNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidEmbeddedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinEmbeddedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidNestedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinNestedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomDashJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinEmbeddedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinNestedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTreeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOrBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAndBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestLeafJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestDeepTreeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestADeepBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAndDeepBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestDeepLeafJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNilJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptEnumDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAnotherNinOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAnotherNinOptEnumDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTimerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMyExtendableJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOtherExtenableJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinitionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinition_NestedMessageJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedScopeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomContainerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNidOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameCustomTypeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNoExtensionsMapJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithInnerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithInner_InnerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithEmbedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithEmbed_EmbeddedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepPackedNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepPackedNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepPackedNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepPackedNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidEmbeddedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidEmbeddedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidNestedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidNestedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomDashProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomDashProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTreeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTreeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOrBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOrBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestLeafProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestLeafProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepTreeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepTreeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestADeepBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestADeepBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndDeepBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndDeepBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepLeafProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepLeafProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNilProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNilProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTimerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTimerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMyExtendableProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMyExtendableProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOtherExtenableProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOtherExtenableProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinitionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinitionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessageProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessageProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedScopeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedScopeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomContainerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomContainerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNidOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNidOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameCustomTypeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameCustomTypeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinEmbeddedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinEmbeddedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNoExtensionsMapProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNoExtensionsMapProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInnerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInnerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInner_InnerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInner_InnerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestThetestDescription(t *testing.T) { + ThetestDescription() +} +func TestNidOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepPackedNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepPackedNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidEmbeddedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinEmbeddedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidNestedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinNestedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomDashVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinNestedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTreeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOrBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAndBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestLeafVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestDeepTreeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestADeepBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAndDeepBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestDeepLeafVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNilVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptEnumDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAnotherNinOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAnotherNinOptEnumDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTimerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMyExtendableVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOtherExtenableVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinitionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinition_NestedMessageVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedScopeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomContainerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNidOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameCustomTypeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNoExtensionsMapVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithInnerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithInner_InnerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithEmbedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithEmbed_EmbeddedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepPackedNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepPackedNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidEmbeddedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidNestedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinNestedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomDashFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptNativeUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinNestedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestTreeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestOrBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAndBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestLeafFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestDeepTreeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestADeepBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAndDeepBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestDeepLeafFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNilFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAnotherNinOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestTimerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinitionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinition_NestedMessageFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedScopeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomContainerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNidOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameCustomTypeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithInnerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithInner_InnerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithEmbedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithEmbed_EmbeddedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepPackedNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepPackedNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidEmbeddedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinEmbeddedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidNestedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinNestedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomDashGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinEmbeddedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinNestedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTreeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOrBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAndBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestLeafGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestDeepTreeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestADeepBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAndDeepBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestDeepLeafGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNilGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptEnumDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAnotherNinOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAnotherNinOptEnumDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTimerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMyExtendableGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOtherExtenableGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinitionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinition_NestedMessageGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedScopeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomContainerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNidOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameCustomTypeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinEmbeddedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNoExtensionsMapGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithInnerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithInner_InnerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithEmbedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithEmbed_EmbeddedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepPackedNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepPackedNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepPackedNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepPackedNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepPackedNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepPackedNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidEmbeddedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidEmbeddedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidEmbeddedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinEmbeddedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidNestedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidNestedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidNestedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinNestedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomDashSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomDashSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomDash, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomDash(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNativeUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinEmbeddedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinNestedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinNestedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestTreeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkTreeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Tree, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestOrBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkOrBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OrBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedOrBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAndBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAndBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestLeafSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkLeafSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Leaf, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepTreeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkDeepTreeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepTree, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedDeepTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestADeepBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkADeepBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*ADeepBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedADeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndDeepBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAndDeepBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndDeepBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAndDeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepLeafSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkDeepLeafSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepLeaf, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedDeepLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNilSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNilSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nil, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNil(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptEnumDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnumDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAnotherNinOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAnotherNinOptEnumDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnumDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestTimerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkTimerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Timer, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedTimer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMyExtendableSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMyExtendableSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MyExtendable, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMyExtendable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestOtherExtenableSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkOtherExtenableSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OtherExtenable, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedOtherExtenable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinitionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinitionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessageSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinition_NestedMessageSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedScopeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedScopeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedScope, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedScope(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNativeDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomContainerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomContainerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomContainer, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomContainer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNidOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNidOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNidOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameCustomTypeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameCustomTypeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameCustomType, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameCustomType(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinEmbeddedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinEmbeddedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinEmbeddedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNoExtensionsMapSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNoExtensionsMapSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NoExtensionsMap, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNoExtensionsMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Unrecognized, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognized(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInnerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithInnerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInner_InnerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithInner_InnerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner_Inner, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithEmbedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbed_EmbeddedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed_Embedded, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepPackedNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepPackedNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidEmbeddedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinEmbeddedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidNestedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinNestedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomDashStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinEmbeddedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinNestedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTreeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOrBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAndBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestLeafStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestDeepTreeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestADeepBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAndDeepBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestDeepLeafStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNilStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptEnumDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAnotherNinOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAnotherNinOptEnumDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTimerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestMyExtendableStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOtherExtenableStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinitionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinition_NestedMessageStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedScopeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomContainerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNidOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameCustomTypeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinEmbeddedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNoExtensionsMapStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithInnerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithInner_InnerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithEmbedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithEmbed_EmbeddedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, true) + v := p.GetValue() + msg := &NinOptNativeUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinOptStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, true) + v := p.GetValue() + msg := &NinOptStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + v := p.GetValue() + msg := &NinEmbeddedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinNestedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, true) + v := p.GetValue() + msg := &NinNestedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestTreeOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, true) + v := p.GetValue() + msg := &Tree{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestDeepTreeOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, true) + v := p.GetValue() + msg := &DeepTree{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + v := p.GetValue() + msg := &CustomNameNinEmbeddedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unmarshaler/uuid.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unmarshaler/uuid.go new file mode 100644 index 0000000000000000000000000000000000000000..4c071114bcce237893cd1f0fa4baca9d8663b571 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unmarshaler/uuid.go @@ -0,0 +1,122 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 test + +import ( + "bytes" + "encoding/json" +) + +func PutLittleEndianUint64(b []byte, offset int, v uint64) { + b[offset] = byte(v) + b[offset+1] = byte(v >> 8) + b[offset+2] = byte(v >> 16) + b[offset+3] = byte(v >> 24) + b[offset+4] = byte(v >> 32) + b[offset+5] = byte(v >> 40) + b[offset+6] = byte(v >> 48) + b[offset+7] = byte(v >> 56) +} + +type Uuid []byte + +func (uuid Uuid) Marshal() ([]byte, error) { + if len(uuid) == 0 { + return nil, nil + } + return []byte(uuid), nil +} + +func (uuid Uuid) MarshalTo(data []byte) (n int, err error) { + if len(uuid) == 0 { + return 0, nil + } + copy(data, uuid) + return 16, nil +} + +func (uuid *Uuid) Unmarshal(data []byte) error { + if len(data) == 0 { + uuid = nil + return nil + } + id := Uuid(make([]byte, 16)) + copy(id, data) + *uuid = id + return nil +} + +func (uuid *Uuid) Size() int { + if uuid == nil { + return 0 + } + if len(*uuid) == 0 { + return 0 + } + return 16 +} + +func (uuid Uuid) MarshalJSON() ([]byte, error) { + return json.Marshal([]byte(uuid)) +} + +func (uuid *Uuid) UnmarshalJSON(data []byte) error { + v := new([]byte) + err := json.Unmarshal(data, v) + if err != nil { + return err + } + return uuid.Unmarshal(*v) +} + +func (uuid Uuid) Equal(other Uuid) bool { + return bytes.Equal(uuid[0:], other[0:]) +} + +type int63 interface { + Int63() int64 +} + +func NewPopulatedUuid(r int63) *Uuid { + u := RandV4(r) + return &u +} + +func RandV4(r int63) Uuid { + uuid := make(Uuid, 16) + uuid.RandV4(r) + return uuid +} + +func (uuid Uuid) RandV4(r int63) { + PutLittleEndianUint64(uuid, 0, uint64(r.Int63())) + PutLittleEndianUint64(uuid, 8, uint64(r.Int63())) + uuid[6] = (uuid[6] & 0xf) | 0x40 + uuid[8] = (uuid[8] & 0x3f) | 0x80 +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeboth/bug_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeboth/bug_test.go new file mode 100644 index 0000000000000000000000000000000000000000..264d3982327d7276cc42c9314074f391dde60dfa --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeboth/bug_test.go @@ -0,0 +1,186 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 test + +import ( + "fmt" + "math" + "testing" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +) + +//http://code.google.com/p/goprotobuf/issues/detail?id=39 +func TestBugUint32VarintSize(t *testing.T) { + temp := uint32(math.MaxUint32) + n := &NinOptNative{} + n.Field5 = &temp + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != 6 { + t.Fatalf("data should be length 6, but its %#v", data) + } +} + +func TestBugZeroLengthSliceSize(t *testing.T) { + n := &NinRepPackedNative{ + Field8: []int64{}, + } + size := n.Size() + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != size { + t.Fatalf("expected %v, but got %v", len(data), size) + } +} + +//http://code.google.com/p/goprotobuf/issues/detail?id=40 +func TestBugPackedProtoSize(t *testing.T) { + n := &NinRepPackedNative{ + Field4: []int64{172960727389894724, 2360337516664475010, 860833876131988189, 9068073014890763245, 7794843386260381831, 4023536436053141786, 8992311247496919020, 4330096163611305776, 4490411416244976467, 7873947349172707443, 2754969595834279669, 1360667855926938684, 4771480785172657389, 4875578924966668055, 8070579869808877481, 9128179594766551001, 4630419407064527516, 863844540220372892, 8208727650143073487, 7086117356301045838, 7779695211931506151, 5493835345187563535, 9119767633370806007, 9054342025895349248, 1887303228838508438, 7624573031734528281, 1874668389749611225, 3517684643468970593, 6677697606628877758, 7293473953189936168, 444475066704085538, 8594971141363049302, 1146643249094989673, 733393306232853371, 7721178528893916886, 7784452000911004429, 6436373110242711440, 6897422461738321237, 8772249155667732778, 6211871464311393541, 3061903718310406883, 7845488913176136641, 8342255034663902574, 3443058984649725748, 8410801047334832902, 7496541071517841153, 4305416923521577765, 7814967600020476457, 8671843803465481186, 3490266370361096855, 1447425664719091336, 653218597262334239, 8306243902880091940, 7851896059762409081, 5936760560798954978, 5755724498441478025, 7022701569985035966, 3707709584811468220, 529069456924666920, 7986469043681522462, 3092513330689518836, 5103541550470476202, 3577384161242626406, 3733428084624703294, 8388690542440473117, 3262468785346149388, 8788358556558007570, 5476276940198542020, 7277903243119461239, 5065861426928605020, 7533460976202697734, 1749213838654236956, 557497603941617931, 5496307611456481108, 6444547750062831720, 6992758776744205596, 7356719693428537399, 2896328872476734507, 381447079530132038, 598300737753233118, 3687980626612697715, 7240924191084283349, 8172414415307971170, 4847024388701257185, 2081764168600256551, 3394217778539123488, 6244660626429310923, 8301712215675381614, 5360615125359461174, 8410140945829785773, 3152963269026381373, 6197275282781459633, 4419829061407546410, 6262035523070047537, 2837207483933463885, 2158105736666826128, 8150764172235490711}, + Field7: []int32{249451845, 1409974015, 393609128, 435232428, 1817529040, 91769006, 861170933, 1556185603, 1568580279, 1236375273, 512276621, 693633711, 967580535, 1950715977, 853431462, 1362390253, 159591204, 111900629, 322985263, 279671129, 1592548430, 465651370, 733849989, 1172059400, 1574824441, 263541092, 1271612397, 1520584358, 467078791, 117698716, 1098255064, 2054264846, 1766452305, 1267576395, 1557505617, 1187833560, 956187431, 1970977586, 1160235159, 1610259028, 489585797, 459139078, 566263183, 954319278, 1545018565, 1753946743, 948214318, 422878159, 883926576, 1424009347, 824732372, 1290433180, 80297942, 417294230, 1402647904, 2078392782, 220505045, 787368129, 463781454, 293083578, 808156928, 293976361}, + Field9: []uint32{0xaa4976e8, 0x3da8cc4c, 0x8c470d83, 0x344d964e, 0x5b90925, 0xa4c4d34e, 0x666eff19, 0xc238e552, 0x9be53bb6, 0x56364245, 0x33ee079d, 0x96bf0ede, 0x7941b74f, 0xdb07cb47, 0x6d76d827, 0x9b211d5d, 0x2798adb6, 0xe48b0c3b, 0x87061b21, 0x48f4e4d2, 0x3e5d5c12, 0x5ee91288, 0x336d4f35, 0xe1d44941, 0xc065548d, 0x2953d73f, 0x873af451, 0xfc769db, 0x9f1bf8da, 0x9baafdfc, 0xf1d3d770, 0x5bb5d2b4, 0xc2c67c48, 0x6845c4c1, 0xa48f32b0, 0xbb04bb70, 0xa5b1ca36, 0x8d98356a, 0x2171f654, 0x5ae279b0, 0x6c4a3d6b, 0x4fff5468, 0xcf9bf851, 0x68513614, 0xdbecd9b0, 0x9553ed3c, 0xa494a736, 0x42205438, 0xbf8e5caa, 0xd3283c6, 0x76d20788, 0x9179826f, 0x96b24f85, 0xbc2eacf4, 0xe4afae0b, 0x4bca85cb, 0x35e63b5b, 0xd7ccee0c, 0x2b506bb9, 0xe78e9f44, 0x9ad232f1, 0x99a37335, 0xa5d6ffc8}, + Field11: []uint64{0x53c01ebc, 0x4fb85ba6, 0x8805eea1, 0xb20ec896, 0x93b63410, 0xec7c9492, 0x50765a28, 0x19592106, 0x2ecc59b3, 0x39cd474f, 0xe4c9e47, 0x444f48c5, 0xe7731d32, 0xf3f43975, 0x603caedd, 0xbb05a1af, 0xa808e34e, 0x88580b07, 0x4c96bbd1, 0x730b4ab9, 0xed126e2b, 0x6db48205, 0x154ba1b9, 0xc26bfb6a, 0x389aa052, 0x869d966c, 0x7c86b366, 0xcc8edbcd, 0xfa8d6dad, 0xcf5857d9, 0x2d9cda0f, 0x1218a0b8, 0x41bf997, 0xf0ca65ac, 0xa610d4b9, 0x8d362e28, 0xb7212d87, 0x8e0fe109, 0xbee041d9, 0x759be2f6, 0x35fef4f3, 0xaeacdb71, 0x10888852, 0xf4e28117, 0xe2a14812, 0x73b748dc, 0xd1c3c6b2, 0xfef41bf0, 0xc9b43b62, 0x810e4faa, 0xcaa41c06, 0x1893fe0d, 0xedc7c850, 0xd12b9eaa, 0x467ee1a9, 0xbe84756b, 0xda7b1680, 0xdc069ffe, 0xf1e7e9f9, 0xb3d95370, 0xa92b77df, 0x5693ac41, 0xd04b7287, 0x27aebf15, 0x837b316e, 0x4dbe2263, 0xbab70c67, 0x547dab21, 0x3c346c1f, 0xb8ef0e4e, 0xfe2d03ce, 0xe1d75955, 0xfec1306, 0xba35c23e, 0xb784ed04, 0x2a4e33aa, 0x7e19d09a, 0x3827c1fe, 0xf3a51561, 0xef765e2b, 0xb044256c, 0x62b322be, 0xf34d56be, 0xeb71b369, 0xffe1294f, 0x237fe8d0, 0x77a1473b, 0x239e1196, 0xdd19bf3d, 0x82c91fe1, 0x95361c57, 0xffea3f1b, 0x1a094c84}, + Field12: []int64{8308420747267165049, 3664160795077875961, 7868970059161834817, 7237335984251173739, 5254748003907196506, 3362259627111837480, 430460752854552122, 5119635556501066533, 1277716037866233522, 9185775384759813768, 833932430882717888, 7986528304451297640, 6792233378368656337, 2074207091120609721, 1788723326198279432, 7756514594746453657, 2283775964901597324, 3061497730110517191, 7733947890656120277, 626967303632386244, 7822928600388582821, 3489658753000061230, 168869995163005961, 248814782163480763, 477885608911386247, 4198422415674133867, 3379354662797976109, 9925112544736939, 1486335136459138480, 4561560414032850671, 1010864164014091267, 186722821683803084, 5106357936724819318, 1298160820191228988, 4675403242419953145, 7130634540106489752, 7101280006672440929, 7176058292431955718, 9109875054097770321, 6810974877085322872, 4736707874303993641, 8993135362721382187, 6857881554990254283, 3704748883307461680, 1099360832887634994, 5207691918707192633, 5984721695043995243}, + } + size := proto.Size(n) + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != size { + t.Fatalf("expected %v, but got %v diff is %v", len(data), size, len(data)-size) + } +} + +func testSize(m interface { + proto.Message + Size() int +}, desc string, expected int) ([]byte, error) { + data, err := proto.Marshal(m) + if err != nil { + return nil, err + } + protoSize := proto.Size(m) + mSize := m.Size() + lenData := len(data) + if protoSize != mSize || protoSize != lenData || mSize != lenData { + return nil, fmt.Errorf("%s proto.Size(m){%d} != m.Size(){%d} != len(data){%d}", desc, protoSize, mSize, lenData) + } + if got := protoSize; got != expected { + return nil, fmt.Errorf("%s proto.Size(m) got %d expected %d", desc, got, expected) + } + if got := mSize; got != expected { + return nil, fmt.Errorf("%s m.Size() got %d expected %d", desc, got, expected) + } + if got := lenData; got != expected { + return nil, fmt.Errorf("%s len(data) got %d expected %d", desc, got, expected) + } + return data, nil +} + +func TestInt32Int64Compatibility(t *testing.T) { + + //test nullable int32 and int64 + + data1, err := testSize(&NinOptNative{ + Field3: proto.Int32(-1), + }, "nullable", 11) + if err != nil { + t.Error(err) + } + //change marshaled data1 to unmarshal into 4th field which is an int64 + data1[0] = uint8(uint32(4 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + u1 := &NinOptNative{} + if err := proto.Unmarshal(data1, u1); err != nil { + t.Error(err) + } + if !u1.Equal(&NinOptNative{ + Field4: proto.Int64(-1), + }) { + t.Error("nullable unmarshaled int32 is not the same int64") + } + + //test non-nullable int32 and int64 + + data2, err := testSize(&NidOptNative{ + Field3: -1, + }, "non nullable", 67) + if err != nil { + t.Error(err) + } + //change marshaled data2 to unmarshal into 4th field which is an int64 + field3 := uint8(uint32(3 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + field4 := uint8(uint32(4 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + for i, c := range data2 { + if c == field4 { + data2[i] = field3 + } else if c == field3 { + data2[i] = field4 + } + } + u2 := &NidOptNative{} + if err := proto.Unmarshal(data2, u2); err != nil { + t.Error(err) + } + if !u2.Equal(&NidOptNative{ + Field4: -1, + }) { + t.Error("non nullable unmarshaled int32 is not the same int64") + } + + //test packed repeated int32 and int64 + + m4 := &NinRepPackedNative{ + Field3: []int32{-1}, + } + data4, err := testSize(m4, "packed", 12) + if err != nil { + t.Error(err) + } + u4 := &NinRepPackedNative{} + if err := proto.Unmarshal(data4, u4); err != nil { + t.Error(err) + } + if err := u4.VerboseEqual(m4); err != nil { + t.Fatalf("%#v", u4) + } + + //test repeated int32 and int64 + + if _, err := testSize(&NinRepNative{ + Field3: []int32{-1}, + }, "repeated", 11); err != nil { + t.Error(err) + } + + t.Logf("tested all") +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeboth/thetest.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeboth/thetest.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..467e38ce21dfc3e4efdec5f36f517da664ccd0f2 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeboth/thetest.pb.go @@ -0,0 +1,36255 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeboth/thetest.proto +// DO NOT EDIT! + +/* + Package test is a generated protocol buffer package. + + It is generated from these files: + combos/unsafeboth/thetest.proto + + It has these top-level messages: + NidOptNative + NinOptNative + NidRepNative + NinRepNative + NidRepPackedNative + NinRepPackedNative + NidOptStruct + NinOptStruct + NidRepStruct + NinRepStruct + NidEmbeddedStruct + NinEmbeddedStruct + NidNestedStruct + NinNestedStruct + NidOptCustom + CustomDash + NinOptCustom + NidRepCustom + NinRepCustom + NinOptNativeUnion + NinOptStructUnion + NinEmbeddedStructUnion + NinNestedStructUnion + Tree + OrBranch + AndBranch + Leaf + DeepTree + ADeepBranch + AndDeepBranch + DeepLeaf + Nil + NidOptEnum + NinOptEnum + NidRepEnum + NinRepEnum + NinOptEnumDefault + AnotherNinOptEnum + AnotherNinOptEnumDefault + Timer + MyExtendable + OtherExtenable + NestedDefinition + NestedScope + NinOptNativeDefault + CustomContainer + CustomNameNidOptNative + CustomNameNinOptNative + CustomNameNinRepNative + CustomNameNinStruct + CustomNameCustomType + CustomNameNinEmbeddedStructUnion + CustomNameEnum + NoExtensionsMap + Unrecognized + UnrecognizedWithInner + UnrecognizedWithEmbed +*/ +package test + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_custom "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom" +import github_com_gogo_protobuf_test_custom_dash_type "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom-dash-type" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" + +import unsafe "unsafe" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type TheTestEnum int32 + +const ( + A TheTestEnum = 0 + B TheTestEnum = 1 + C TheTestEnum = 2 +) + +var TheTestEnum_name = map[int32]string{ + 0: "A", + 1: "B", + 2: "C", +} +var TheTestEnum_value = map[string]int32{ + "A": 0, + "B": 1, + "C": 2, +} + +func (x TheTestEnum) Enum() *TheTestEnum { + p := new(TheTestEnum) + *p = x + return p +} +func (x TheTestEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(TheTestEnum_name, int32(x)) +} +func (x *TheTestEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(TheTestEnum_value, data, "TheTestEnum") + if err != nil { + return err + } + *x = TheTestEnum(value) + return nil +} + +type AnotherTestEnum int32 + +const ( + D AnotherTestEnum = 10 + E AnotherTestEnum = 11 +) + +var AnotherTestEnum_name = map[int32]string{ + 10: "D", + 11: "E", +} +var AnotherTestEnum_value = map[string]int32{ + "D": 10, + "E": 11, +} + +func (x AnotherTestEnum) Enum() *AnotherTestEnum { + p := new(AnotherTestEnum) + *p = x + return p +} +func (x AnotherTestEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(AnotherTestEnum_name, int32(x)) +} +func (x *AnotherTestEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(AnotherTestEnum_value, data, "AnotherTestEnum") + if err != nil { + return err + } + *x = AnotherTestEnum(value) + return nil +} + +type NestedDefinition_NestedEnum int32 + +const ( + TYPE_NESTED NestedDefinition_NestedEnum = 1 +) + +var NestedDefinition_NestedEnum_name = map[int32]string{ + 1: "TYPE_NESTED", +} +var NestedDefinition_NestedEnum_value = map[string]int32{ + "TYPE_NESTED": 1, +} + +func (x NestedDefinition_NestedEnum) Enum() *NestedDefinition_NestedEnum { + p := new(NestedDefinition_NestedEnum) + *p = x + return p +} +func (x NestedDefinition_NestedEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(NestedDefinition_NestedEnum_name, int32(x)) +} +func (x *NestedDefinition_NestedEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(NestedDefinition_NestedEnum_value, data, "NestedDefinition_NestedEnum") + if err != nil { + return err + } + *x = NestedDefinition_NestedEnum(value) + return nil +} + +type NidOptNative struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + Field3 int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3"` + Field4 int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4"` + Field5 uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5"` + Field6 uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8"` + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9"` + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10"` + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11"` + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12"` + Field13 bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + Field14 string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptNative) Reset() { *m = NidOptNative{} } +func (*NidOptNative) ProtoMessage() {} + +type NinOptNative struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"` + Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"` + Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"` + Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"` + Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNative) Reset() { *m = NinOptNative{} } +func (*NinOptNative) ProtoMessage() {} + +type NidRepNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepNative) Reset() { *m = NidRepNative{} } +func (*NidRepNative) ProtoMessage() {} + +type NinRepNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepNative) Reset() { *m = NinRepNative{} } +func (*NinRepNative) ProtoMessage() {} + +type NidRepPackedNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepPackedNative) Reset() { *m = NidRepPackedNative{} } +func (*NidRepPackedNative) ProtoMessage() {} + +type NinRepPackedNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepPackedNative) Reset() { *m = NinRepPackedNative{} } +func (*NinRepPackedNative) ProtoMessage() {} + +type NidOptStruct struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + Field3 NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3"` + Field4 NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4"` + Field6 uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + Field8 NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8"` + Field13 bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + Field14 string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptStruct) Reset() { *m = NidOptStruct{} } +func (*NidOptStruct) ProtoMessage() {} + +type NinOptStruct struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field8 *NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptStruct) Reset() { *m = NinOptStruct{} } +func (*NinOptStruct) ProtoMessage() {} + +type NidRepStruct struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []NidOptNative `protobuf:"bytes,3,rep,name=Field3" json:"Field3"` + Field4 []NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []NidOptNative `protobuf:"bytes,8,rep,name=Field8" json:"Field8"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepStruct) Reset() { *m = NidRepStruct{} } +func (*NidRepStruct) ProtoMessage() {} + +type NinRepStruct struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []*NidOptNative `protobuf:"bytes,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []*NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []*NidOptNative `protobuf:"bytes,8,rep,name=Field8" json:"Field8,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepStruct) Reset() { *m = NinRepStruct{} } +func (*NinRepStruct) ProtoMessage() {} + +type NidEmbeddedStruct struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 NidOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200"` + Field210 bool `protobuf:"varint,210,opt,name=Field210" json:"Field210"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidEmbeddedStruct) Reset() { *m = NidEmbeddedStruct{} } +func (*NidEmbeddedStruct) ProtoMessage() {} + +type NinEmbeddedStruct struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 *NidOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + Field210 *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinEmbeddedStruct) Reset() { *m = NinEmbeddedStruct{} } +func (*NinEmbeddedStruct) ProtoMessage() {} + +type NidNestedStruct struct { + Field1 NidOptStruct `protobuf:"bytes,1,opt,name=Field1" json:"Field1"` + Field2 []NidRepStruct `protobuf:"bytes,2,rep,name=Field2" json:"Field2"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidNestedStruct) Reset() { *m = NidNestedStruct{} } +func (*NidNestedStruct) ProtoMessage() {} + +type NinNestedStruct struct { + Field1 *NinOptStruct `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 []*NinRepStruct `protobuf:"bytes,2,rep,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinNestedStruct) Reset() { *m = NinNestedStruct{} } +func (*NinNestedStruct) ProtoMessage() {} + +type NidOptCustom struct { + Id Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id"` + Value github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptCustom) Reset() { *m = NidOptCustom{} } +func (*NidOptCustom) ProtoMessage() {} + +type CustomDash struct { + Value *github_com_gogo_protobuf_test_custom_dash_type.Bytes `protobuf:"bytes,1,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom-dash-type.Bytes" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomDash) Reset() { *m = CustomDash{} } +func (*CustomDash) ProtoMessage() {} + +type NinOptCustom struct { + Id *Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id,omitempty"` + Value *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptCustom) Reset() { *m = NinOptCustom{} } +func (*NinOptCustom) ProtoMessage() {} + +type NidRepCustom struct { + Id []Uuid `protobuf:"bytes,1,rep,name=Id,customtype=Uuid" json:"Id"` + Value []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepCustom) Reset() { *m = NidRepCustom{} } +func (*NidRepCustom) ProtoMessage() {} + +type NinRepCustom struct { + Id []Uuid `protobuf:"bytes,1,rep,name=Id,customtype=Uuid" json:"Id,omitempty"` + Value []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepCustom) Reset() { *m = NinRepCustom{} } +func (*NinRepCustom) ProtoMessage() {} + +type NinOptNativeUnion struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNativeUnion) Reset() { *m = NinOptNativeUnion{} } +func (*NinOptNativeUnion) ProtoMessage() {} + +type NinOptStructUnion struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptStructUnion) Reset() { *m = NinOptStructUnion{} } +func (*NinOptStructUnion) ProtoMessage() {} + +type NinEmbeddedStructUnion struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 *NinOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + Field210 *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinEmbeddedStructUnion) Reset() { *m = NinEmbeddedStructUnion{} } +func (*NinEmbeddedStructUnion) ProtoMessage() {} + +type NinNestedStructUnion struct { + Field1 *NinOptNativeUnion `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *NinOptStructUnion `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NinEmbeddedStructUnion `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinNestedStructUnion) Reset() { *m = NinNestedStructUnion{} } +func (*NinNestedStructUnion) ProtoMessage() {} + +type Tree struct { + Or *OrBranch `protobuf:"bytes,1,opt,name=Or" json:"Or,omitempty"` + And *AndBranch `protobuf:"bytes,2,opt,name=And" json:"And,omitempty"` + Leaf *Leaf `protobuf:"bytes,3,opt,name=Leaf" json:"Leaf,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Tree) Reset() { *m = Tree{} } +func (*Tree) ProtoMessage() {} + +type OrBranch struct { + Left Tree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right Tree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OrBranch) Reset() { *m = OrBranch{} } +func (*OrBranch) ProtoMessage() {} + +type AndBranch struct { + Left Tree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right Tree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AndBranch) Reset() { *m = AndBranch{} } +func (*AndBranch) ProtoMessage() {} + +type Leaf struct { + Value int64 `protobuf:"varint,1,opt,name=Value" json:"Value"` + StrValue string `protobuf:"bytes,2,opt,name=StrValue" json:"StrValue"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Leaf) Reset() { *m = Leaf{} } +func (*Leaf) ProtoMessage() {} + +type DeepTree struct { + Down *ADeepBranch `protobuf:"bytes,1,opt,name=Down" json:"Down,omitempty"` + And *AndDeepBranch `protobuf:"bytes,2,opt,name=And" json:"And,omitempty"` + Leaf *DeepLeaf `protobuf:"bytes,3,opt,name=Leaf" json:"Leaf,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeepTree) Reset() { *m = DeepTree{} } +func (*DeepTree) ProtoMessage() {} + +type ADeepBranch struct { + Down DeepTree `protobuf:"bytes,2,opt,name=Down" json:"Down"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ADeepBranch) Reset() { *m = ADeepBranch{} } +func (*ADeepBranch) ProtoMessage() {} + +type AndDeepBranch struct { + Left DeepTree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right DeepTree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AndDeepBranch) Reset() { *m = AndDeepBranch{} } +func (*AndDeepBranch) ProtoMessage() {} + +type DeepLeaf struct { + Tree Tree `protobuf:"bytes,1,opt,name=Tree" json:"Tree"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeepLeaf) Reset() { *m = DeepLeaf{} } +func (*DeepLeaf) ProtoMessage() {} + +type Nil struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *Nil) Reset() { *m = Nil{} } +func (*Nil) ProtoMessage() {} + +type NidOptEnum struct { + Field1 TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptEnum) Reset() { *m = NidOptEnum{} } +func (*NidOptEnum) ProtoMessage() {} + +type NinOptEnum struct { + Field1 *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptEnum) Reset() { *m = NinOptEnum{} } +func (*NinOptEnum) ProtoMessage() {} + +type NidRepEnum struct { + Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepEnum) Reset() { *m = NidRepEnum{} } +func (*NidRepEnum) ProtoMessage() {} + +type NinRepEnum struct { + Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepEnum) Reset() { *m = NinRepEnum{} } +func (*NinRepEnum) ProtoMessage() {} + +type NinOptEnumDefault struct { + Field1 *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum,def=2" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptEnumDefault) Reset() { *m = NinOptEnumDefault{} } +func (*NinOptEnumDefault) ProtoMessage() {} + +const Default_NinOptEnumDefault_Field1 TheTestEnum = C + +func (m *NinOptEnumDefault) GetField1() TheTestEnum { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_NinOptEnumDefault_Field1 +} + +type AnotherNinOptEnum struct { + Field1 *AnotherTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.AnotherTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AnotherNinOptEnum) Reset() { *m = AnotherNinOptEnum{} } +func (*AnotherNinOptEnum) ProtoMessage() {} + +type AnotherNinOptEnumDefault struct { + Field1 *AnotherTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.AnotherTestEnum,def=11" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AnotherNinOptEnumDefault) Reset() { *m = AnotherNinOptEnumDefault{} } +func (*AnotherNinOptEnumDefault) ProtoMessage() {} + +const Default_AnotherNinOptEnumDefault_Field1 AnotherTestEnum = E + +func (m *AnotherNinOptEnumDefault) GetField1() AnotherTestEnum { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_AnotherNinOptEnumDefault_Field1 +} + +type Timer struct { + Time1 int64 `protobuf:"fixed64,1,opt,name=Time1" json:"Time1"` + Time2 int64 `protobuf:"fixed64,2,opt,name=Time2" json:"Time2"` + Data []byte `protobuf:"bytes,3,opt,name=Data" json:"Data"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Timer) Reset() { *m = Timer{} } +func (*Timer) ProtoMessage() {} + +type MyExtendable struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MyExtendable) Reset() { *m = MyExtendable{} } +func (*MyExtendable) ProtoMessage() {} + +var extRange_MyExtendable = []proto.ExtensionRange{ + {100, 199}, +} + +func (*MyExtendable) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MyExtendable +} +func (m *MyExtendable) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type OtherExtenable struct { + Field2 *int64 `protobuf:"varint,2,opt,name=Field2" json:"Field2,omitempty"` + Field13 *int64 `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + M *MyExtendable `protobuf:"bytes,1,opt,name=M" json:"M,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OtherExtenable) Reset() { *m = OtherExtenable{} } +func (*OtherExtenable) ProtoMessage() {} + +var extRange_OtherExtenable = []proto.ExtensionRange{ + {14, 16}, + {10, 12}, +} + +func (*OtherExtenable) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_OtherExtenable +} +func (m *OtherExtenable) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type NestedDefinition struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + EnumField *NestedDefinition_NestedEnum `protobuf:"varint,2,opt,name=EnumField,enum=test.NestedDefinition_NestedEnum" json:"EnumField,omitempty"` + NNM *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,3,opt,name=NNM" json:"NNM,omitempty"` + NM *NestedDefinition_NestedMessage `protobuf:"bytes,4,opt,name=NM" json:"NM,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition) Reset() { *m = NestedDefinition{} } +func (*NestedDefinition) ProtoMessage() {} + +type NestedDefinition_NestedMessage struct { + NestedField1 *uint64 `protobuf:"fixed64,1,opt,name=NestedField1" json:"NestedField1,omitempty"` + NNM *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,2,opt,name=NNM" json:"NNM,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition_NestedMessage) Reset() { *m = NestedDefinition_NestedMessage{} } +func (*NestedDefinition_NestedMessage) ProtoMessage() {} + +type NestedDefinition_NestedMessage_NestedNestedMsg struct { + NestedNestedField1 *string `protobuf:"bytes,10,opt,name=NestedNestedField1" json:"NestedNestedField1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Reset() { + *m = NestedDefinition_NestedMessage_NestedNestedMsg{} +} +func (*NestedDefinition_NestedMessage_NestedNestedMsg) ProtoMessage() {} + +type NestedScope struct { + A *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,1,opt,name=A" json:"A,omitempty"` + B *NestedDefinition_NestedEnum `protobuf:"varint,2,opt,name=B,enum=test.NestedDefinition_NestedEnum" json:"B,omitempty"` + C *NestedDefinition_NestedMessage `protobuf:"bytes,3,opt,name=C" json:"C,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedScope) Reset() { *m = NestedScope{} } +func (*NestedScope) ProtoMessage() {} + +type NinOptNativeDefault struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1,def=1234.1234" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2,def=1234.1234" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3,def=1234" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4,def=1234" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5,def=1234" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6,def=1234" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7,def=1234" json:"Field7,omitempty"` + Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8,def=1234" json:"Field8,omitempty"` + Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9,def=1234" json:"Field9,omitempty"` + Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10,def=1234" json:"Field10,omitempty"` + Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11,def=1234" json:"Field11,omitempty"` + Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12,def=1234" json:"Field12,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13,def=1" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14,def=1234" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNativeDefault) Reset() { *m = NinOptNativeDefault{} } +func (*NinOptNativeDefault) ProtoMessage() {} + +const Default_NinOptNativeDefault_Field1 float64 = 1234.1234 +const Default_NinOptNativeDefault_Field2 float32 = 1234.1234 +const Default_NinOptNativeDefault_Field3 int32 = 1234 +const Default_NinOptNativeDefault_Field4 int64 = 1234 +const Default_NinOptNativeDefault_Field5 uint32 = 1234 +const Default_NinOptNativeDefault_Field6 uint64 = 1234 +const Default_NinOptNativeDefault_Field7 int32 = 1234 +const Default_NinOptNativeDefault_Field8 int64 = 1234 +const Default_NinOptNativeDefault_Field9 uint32 = 1234 +const Default_NinOptNativeDefault_Field10 int32 = 1234 +const Default_NinOptNativeDefault_Field11 uint64 = 1234 +const Default_NinOptNativeDefault_Field12 int64 = 1234 +const Default_NinOptNativeDefault_Field13 bool = true +const Default_NinOptNativeDefault_Field14 string = "1234" + +func (m *NinOptNativeDefault) GetField1() float64 { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_NinOptNativeDefault_Field1 +} + +func (m *NinOptNativeDefault) GetField2() float32 { + if m != nil && m.Field2 != nil { + return *m.Field2 + } + return Default_NinOptNativeDefault_Field2 +} + +func (m *NinOptNativeDefault) GetField3() int32 { + if m != nil && m.Field3 != nil { + return *m.Field3 + } + return Default_NinOptNativeDefault_Field3 +} + +func (m *NinOptNativeDefault) GetField4() int64 { + if m != nil && m.Field4 != nil { + return *m.Field4 + } + return Default_NinOptNativeDefault_Field4 +} + +func (m *NinOptNativeDefault) GetField5() uint32 { + if m != nil && m.Field5 != nil { + return *m.Field5 + } + return Default_NinOptNativeDefault_Field5 +} + +func (m *NinOptNativeDefault) GetField6() uint64 { + if m != nil && m.Field6 != nil { + return *m.Field6 + } + return Default_NinOptNativeDefault_Field6 +} + +func (m *NinOptNativeDefault) GetField7() int32 { + if m != nil && m.Field7 != nil { + return *m.Field7 + } + return Default_NinOptNativeDefault_Field7 +} + +func (m *NinOptNativeDefault) GetField8() int64 { + if m != nil && m.Field8 != nil { + return *m.Field8 + } + return Default_NinOptNativeDefault_Field8 +} + +func (m *NinOptNativeDefault) GetField9() uint32 { + if m != nil && m.Field9 != nil { + return *m.Field9 + } + return Default_NinOptNativeDefault_Field9 +} + +func (m *NinOptNativeDefault) GetField10() int32 { + if m != nil && m.Field10 != nil { + return *m.Field10 + } + return Default_NinOptNativeDefault_Field10 +} + +func (m *NinOptNativeDefault) GetField11() uint64 { + if m != nil && m.Field11 != nil { + return *m.Field11 + } + return Default_NinOptNativeDefault_Field11 +} + +func (m *NinOptNativeDefault) GetField12() int64 { + if m != nil && m.Field12 != nil { + return *m.Field12 + } + return Default_NinOptNativeDefault_Field12 +} + +func (m *NinOptNativeDefault) GetField13() bool { + if m != nil && m.Field13 != nil { + return *m.Field13 + } + return Default_NinOptNativeDefault_Field13 +} + +func (m *NinOptNativeDefault) GetField14() string { + if m != nil && m.Field14 != nil { + return *m.Field14 + } + return Default_NinOptNativeDefault_Field14 +} + +func (m *NinOptNativeDefault) GetField15() []byte { + if m != nil { + return m.Field15 + } + return nil +} + +type CustomContainer struct { + CustomStruct NidOptCustom `protobuf:"bytes,1,opt,name=CustomStruct" json:"CustomStruct"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomContainer) Reset() { *m = CustomContainer{} } +func (*CustomContainer) ProtoMessage() {} + +type CustomNameNidOptNative struct { + FieldA float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + FieldB float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + FieldC int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3"` + FieldD int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4"` + FieldE uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5"` + FieldF uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + FieldG int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + FieldH int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8"` + FieldI uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9"` + FieldJ int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10"` + FieldK uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11"` + FieldL int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12"` + FieldM bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + FieldN string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + FieldO []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNidOptNative) Reset() { *m = CustomNameNidOptNative{} } +func (*CustomNameNidOptNative) ProtoMessage() {} + +type CustomNameNinOptNative struct { + FieldA *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + FieldB *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + FieldC *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + FieldD *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + FieldE *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + FieldF *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + FieldG *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + FieldH *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"` + FieldI *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"` + FieldJ *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"` + FieldK *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"` + FielL *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"` + FieldM *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + FieldN *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + FieldO []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinOptNative) Reset() { *m = CustomNameNinOptNative{} } +func (*CustomNameNinOptNative) ProtoMessage() {} + +type CustomNameNinRepNative struct { + FieldA []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + FieldB []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + FieldC []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + FieldD []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + FieldE []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + FieldF []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + FieldG []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + FieldH []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + FieldI []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + FieldJ []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + FieldK []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + FieldL []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + FieldM []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + FieldN []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + FieldO [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinRepNative) Reset() { *m = CustomNameNinRepNative{} } +func (*CustomNameNinRepNative) ProtoMessage() {} + +type CustomNameNinStruct struct { + FieldA *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + FieldB *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + FieldC *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + FieldD []*NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4,omitempty"` + FieldE *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + FieldF *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + FieldG *NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"` + FieldH *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + FieldI *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + FieldJ []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinStruct) Reset() { *m = CustomNameNinStruct{} } +func (*CustomNameNinStruct) ProtoMessage() {} + +type CustomNameCustomType struct { + FieldA *Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id,omitempty"` + FieldB *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + FieldC []Uuid `protobuf:"bytes,3,rep,name=Ids,customtype=Uuid" json:"Ids,omitempty"` + FieldD []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,4,rep,name=Values,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Values,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameCustomType) Reset() { *m = CustomNameCustomType{} } +func (*CustomNameCustomType) ProtoMessage() {} + +type CustomNameNinEmbeddedStructUnion struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + FieldA *NinOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + FieldB *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinEmbeddedStructUnion) Reset() { *m = CustomNameNinEmbeddedStructUnion{} } +func (*CustomNameNinEmbeddedStructUnion) ProtoMessage() {} + +type CustomNameEnum struct { + FieldA *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + FieldB []TheTestEnum `protobuf:"varint,2,rep,name=Field2,enum=test.TheTestEnum" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameEnum) Reset() { *m = CustomNameEnum{} } +func (*CustomNameEnum) ProtoMessage() {} + +type NoExtensionsMap struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + XXX_extensions []byte `protobuf:"bytes,0,opt" json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NoExtensionsMap) Reset() { *m = NoExtensionsMap{} } +func (*NoExtensionsMap) ProtoMessage() {} + +var extRange_NoExtensionsMap = []proto.ExtensionRange{ + {100, 199}, +} + +func (*NoExtensionsMap) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_NoExtensionsMap +} +func (m *NoExtensionsMap) GetExtensions() *[]byte { + if m.XXX_extensions == nil { + m.XXX_extensions = make([]byte, 0) + } + return &m.XXX_extensions +} + +type Unrecognized struct { + Field1 *string `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *Unrecognized) Reset() { *m = Unrecognized{} } +func (*Unrecognized) ProtoMessage() {} + +type UnrecognizedWithInner struct { + Embedded []*UnrecognizedWithInner_Inner `protobuf:"bytes,1,rep,name=embedded" json:"embedded,omitempty"` + Field2 *string `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnrecognizedWithInner) Reset() { *m = UnrecognizedWithInner{} } +func (*UnrecognizedWithInner) ProtoMessage() {} + +type UnrecognizedWithInner_Inner struct { + Field1 *uint32 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *UnrecognizedWithInner_Inner) Reset() { *m = UnrecognizedWithInner_Inner{} } +func (*UnrecognizedWithInner_Inner) ProtoMessage() {} + +type UnrecognizedWithEmbed struct { + UnrecognizedWithEmbed_Embedded `protobuf:"bytes,1,opt,name=embedded,embedded=embedded" json:"embedded"` + Field2 *string `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnrecognizedWithEmbed) Reset() { *m = UnrecognizedWithEmbed{} } +func (*UnrecognizedWithEmbed) ProtoMessage() {} + +type UnrecognizedWithEmbed_Embedded struct { + Field1 *uint32 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *UnrecognizedWithEmbed_Embedded) Reset() { *m = UnrecognizedWithEmbed_Embedded{} } +func (*UnrecognizedWithEmbed_Embedded) ProtoMessage() {} + +var E_FieldA = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*float64)(nil), + Field: 100, + Name: "test.FieldA", + Tag: "fixed64,100,opt,name=FieldA", +} + +var E_FieldB = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*NinOptNative)(nil), + Field: 101, + Name: "test.FieldB", + Tag: "bytes,101,opt,name=FieldB", +} + +var E_FieldC = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*NinEmbeddedStruct)(nil), + Field: 102, + Name: "test.FieldC", + Tag: "bytes,102,opt,name=FieldC", +} + +var E_FieldA1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*float64)(nil), + Field: 100, + Name: "test.FieldA1", + Tag: "fixed64,100,opt,name=FieldA1", +} + +var E_FieldB1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*NinOptNative)(nil), + Field: 101, + Name: "test.FieldB1", + Tag: "bytes,101,opt,name=FieldB1", +} + +var E_FieldC1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*NinEmbeddedStruct)(nil), + Field: 102, + Name: "test.FieldC1", + Tag: "bytes,102,opt,name=FieldC1", +} + +func init() { + proto.RegisterEnum("test.TheTestEnum", TheTestEnum_name, TheTestEnum_value) + proto.RegisterEnum("test.AnotherTestEnum", AnotherTestEnum_name, AnotherTestEnum_value) + proto.RegisterEnum("test.NestedDefinition_NestedEnum", NestedDefinition_NestedEnum_name, NestedDefinition_NestedEnum_value) + proto.RegisterExtension(E_FieldA) + proto.RegisterExtension(E_FieldB) + proto.RegisterExtension(E_FieldC) + proto.RegisterExtension(E_FieldA1) + proto.RegisterExtension(E_FieldB1) + proto.RegisterExtension(E_FieldC1) +} +func (this *NidOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepPackedNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepPackedNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidEmbeddedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinEmbeddedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidNestedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinNestedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomDash) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNativeUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinEmbeddedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinNestedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Tree) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *OrBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AndBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Leaf) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *DeepTree) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *ADeepBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AndDeepBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *DeepLeaf) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Nil) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptEnumDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AnotherNinOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AnotherNinOptEnumDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Timer) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *MyExtendable) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *OtherExtenable) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition_NestedMessage) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedScope) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNativeDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomContainer) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNidOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameCustomType) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinEmbeddedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NoExtensionsMap) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Unrecognized) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithInner) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithInner_Inner) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithEmbed) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithEmbed_Embedded) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func ThetestDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unsafeboth/thetest.proto"), + Package: func(v string) *string { return &v }("test"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NinRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NidOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }, {Name: func(v string) *string { return &v }("NidNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidRepStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStruct"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinRepStruct"), + }}, + }, {Name: func(v string) *string { return &v }("NidOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomDash"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x64, 0x61, 0x73, 0x68, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NidRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinOptStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinNestedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNativeUnion"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStructUnion"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStructUnion"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Tree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Or"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.OrBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Leaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("OrBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Leaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("StrValue"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepTree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.ADeepBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndDeepBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepLeaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("ADeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndDeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepLeaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Tree"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Nil")}, {Name: func(v string) *string { return &v }("NidOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NidRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + DefaultValue: func(v string) *string { return &v }("C"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + DefaultValue: func(v string) *string { return &v }("E"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Timer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Time1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Time2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Data"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("MyExtendable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("OtherExtenable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("M"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.MyExtendable"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(14), + End: func(v int32) *int32 { return &v }(17), + }, {Start: func(v int32) *int32 { return &v }(10), + End: func(v int32) *int32 { return &v }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("NestedDefinition"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("EnumField"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("NM"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedMessage"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedField1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedMsg"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedField1"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("NestedEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_NESTED"), + Number: func(v int32) *int32 { return &v }(1), + }}, + }}, + }, {Name: func(v string) *string { return &v }("NestedScope"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("true"), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("CustomContainer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("CustomStruct"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptCustom"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x5, 0x46, 0x69, 0x65, 0x6c, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameCustomType"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Ids"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Values"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("CustomNameEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + }, {Name: func(v string) *string { return &v }("NoExtensionsMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0}), 64025: proto.NewExtension([]byte{0xc8, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Unrecognized"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithInner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithInner.Inner"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Inner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithEmbed"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithEmbed.Embedded"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Embedded"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("TheTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }, {Name: func(v string) *string { return &v }("AnotherTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("D"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("E"), + Number: func(v int32) *int32 { return &v }(11), + }}, + Options: &google_protobuf.EnumOptions{XXX_extensions: map[int32]proto.Extension{62001: proto.NewExtension([]byte{0x88, 0xa3, 0x1e, 0x0})}}, + }}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("FieldA"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldB"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldC"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldA1"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldB1"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldC1"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x1}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x1})}}, + }}, + } +} +func (x TheTestEnum) String() string { + s, ok := TheTestEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x AnotherTestEnum) String() string { + s, ok := AnotherTestEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x NestedDefinition_NestedEnum) String() string { + s, ok := NestedDefinition_NestedEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *NidOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptNative) + if !ok { + return fmt.Errorf("that is not of type *NidOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptNativebut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if this.Field2 != that1.Field2 { + return false + } + if this.Field3 != that1.Field3 { + return false + } + if this.Field4 != that1.Field4 { + return false + } + if this.Field5 != that1.Field5 { + return false + } + if this.Field6 != that1.Field6 { + return false + } + if this.Field7 != that1.Field7 { + return false + } + if this.Field8 != that1.Field8 { + return false + } + if this.Field9 != that1.Field9 { + return false + } + if this.Field10 != that1.Field10 { + return false + } + if this.Field11 != that1.Field11 { + return false + } + if this.Field12 != that1.Field12 { + return false + } + if this.Field13 != that1.Field13 { + return false + } + if this.Field14 != that1.Field14 { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNative) + if !ok { + return fmt.Errorf("that is not of type *NinOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativebut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", *this.Field8, *that1.Field8) + } + } else if this.Field8 != nil { + return fmt.Errorf("this.Field8 == nil && that.Field8 != nil") + } else if that1.Field8 != nil { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", *this.Field9, *that1.Field9) + } + } else if this.Field9 != nil { + return fmt.Errorf("this.Field9 == nil && that.Field9 != nil") + } else if that1.Field9 != nil { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", *this.Field10, *that1.Field10) + } + } else if this.Field10 != nil { + return fmt.Errorf("this.Field10 == nil && that.Field10 != nil") + } else if that1.Field10 != nil { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", *this.Field11, *that1.Field11) + } + } else if this.Field11 != nil { + return fmt.Errorf("this.Field11 == nil && that.Field11 != nil") + } else if that1.Field11 != nil { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", *this.Field12, *that1.Field12) + } + } else if this.Field12 != nil { + return fmt.Errorf("this.Field12 == nil && that.Field12 != nil") + } else if that1.Field12 != nil { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return false + } + } else if this.Field8 != nil { + return false + } else if that1.Field8 != nil { + return false + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return false + } + } else if this.Field9 != nil { + return false + } else if that1.Field9 != nil { + return false + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return false + } + } else if this.Field10 != nil { + return false + } else if that1.Field10 != nil { + return false + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return false + } + } else if this.Field11 != nil { + return false + } else if that1.Field11 != nil { + return false + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return false + } + } else if this.Field12 != nil { + return false + } else if that1.Field12 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepNative) + if !ok { + return fmt.Errorf("that is not of type *NidRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepNative) + if !ok { + return fmt.Errorf("that is not of type *NinRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepPackedNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepPackedNative) + if !ok { + return fmt.Errorf("that is not of type *NidRepPackedNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepPackedNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepPackedNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepPackedNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepPackedNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepPackedNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepPackedNative) + if !ok { + return fmt.Errorf("that is not of type *NinRepPackedNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepPackedNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepPackedNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepPackedNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepPackedNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptStruct) + if !ok { + return fmt.Errorf("that is not of type *NidOptStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptStructbut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(&that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(&that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if !this.Field8.Equal(&that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if this.Field2 != that1.Field2 { + return false + } + if !this.Field3.Equal(&that1.Field3) { + return false + } + if !this.Field4.Equal(&that1.Field4) { + return false + } + if this.Field6 != that1.Field6 { + return false + } + if this.Field7 != that1.Field7 { + return false + } + if !this.Field8.Equal(&that1.Field8) { + return false + } + if this.Field13 != that1.Field13 { + return false + } + if this.Field14 != that1.Field14 { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptStruct) + if !ok { + return fmt.Errorf("that is not of type *NinOptStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptStructbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if !this.Field8.Equal(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !this.Field4.Equal(that1.Field4) { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if !this.Field8.Equal(that1.Field8) { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepStruct) + if !ok { + return fmt.Errorf("that is not of type *NidRepStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepStructbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if !this.Field3[i].Equal(&that1.Field3[i]) { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if !this.Field4[i].Equal(&that1.Field4[i]) { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if !this.Field8[i].Equal(&that1.Field8[i]) { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if !this.Field3[i].Equal(&that1.Field3[i]) { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if !this.Field4[i].Equal(&that1.Field4[i]) { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if !this.Field8[i].Equal(&that1.Field8[i]) { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepStruct) + if !ok { + return fmt.Errorf("that is not of type *NinRepStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepStructbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if !this.Field3[i].Equal(that1.Field3[i]) { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if !this.Field4[i].Equal(that1.Field4[i]) { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if !this.Field8[i].Equal(that1.Field8[i]) { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if !this.Field3[i].Equal(that1.Field3[i]) { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if !this.Field4[i].Equal(that1.Field4[i]) { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if !this.Field8[i].Equal(that1.Field8[i]) { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidEmbeddedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidEmbeddedStruct) + if !ok { + return fmt.Errorf("that is not of type *NidEmbeddedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidEmbeddedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidEmbeddedStructbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(&that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidEmbeddedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidEmbeddedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(&that1.Field200) { + return false + } + if this.Field210 != that1.Field210 { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinEmbeddedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinEmbeddedStruct) + if !ok { + return fmt.Errorf("that is not of type *NinEmbeddedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinEmbeddedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinEmbeddedStructbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", *this.Field210, *that1.Field210) + } + } else if this.Field210 != nil { + return fmt.Errorf("this.Field210 == nil && that.Field210 != nil") + } else if that1.Field210 != nil { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinEmbeddedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinEmbeddedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(that1.Field200) { + return false + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return false + } + } else if this.Field210 != nil { + return false + } else if that1.Field210 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidNestedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidNestedStruct) + if !ok { + return fmt.Errorf("that is not of type *NidNestedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidNestedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidNestedStructbut is not nil && this == nil") + } + if !this.Field1.Equal(&that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if !this.Field2[i].Equal(&that1.Field2[i]) { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidNestedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidNestedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(&that1.Field1) { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if !this.Field2[i].Equal(&that1.Field2[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinNestedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinNestedStruct) + if !ok { + return fmt.Errorf("that is not of type *NinNestedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinNestedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinNestedStructbut is not nil && this == nil") + } + if !this.Field1.Equal(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if !this.Field2[i].Equal(that1.Field2[i]) { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinNestedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinNestedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(that1.Field1) { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if !this.Field2[i].Equal(that1.Field2[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptCustom) + if !ok { + return fmt.Errorf("that is not of type *NidOptCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptCustombut is not nil && this == nil") + } + if !this.Id.Equal(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id) + } + if !this.Value.Equal(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Id.Equal(that1.Id) { + return false + } + if !this.Value.Equal(that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomDash) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomDash) + if !ok { + return fmt.Errorf("that is not of type *CustomDash") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomDash but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomDashbut is not nil && this == nil") + } + if that1.Value == nil { + if this.Value != nil { + return fmt.Errorf("this.Value != nil && that1.Value == nil") + } + } else if !this.Value.Equal(*that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomDash) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomDash) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Value == nil { + if this.Value != nil { + return false + } + } else if !this.Value.Equal(*that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptCustom) + if !ok { + return fmt.Errorf("that is not of type *NinOptCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptCustombut is not nil && this == nil") + } + if that1.Id == nil { + if this.Id != nil { + return fmt.Errorf("this.Id != nil && that1.Id == nil") + } + } else if !this.Id.Equal(*that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id) + } + if that1.Value == nil { + if this.Value != nil { + return fmt.Errorf("this.Value != nil && that1.Value == nil") + } + } else if !this.Value.Equal(*that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Id == nil { + if this.Id != nil { + return false + } + } else if !this.Id.Equal(*that1.Id) { + return false + } + if that1.Value == nil { + if this.Value != nil { + return false + } + } else if !this.Value.Equal(*that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepCustom) + if !ok { + return fmt.Errorf("that is not of type *NidRepCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepCustombut is not nil && this == nil") + } + if len(this.Id) != len(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", len(this.Id), len(that1.Id)) + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return fmt.Errorf("Id this[%v](%v) Not Equal that[%v](%v)", i, this.Id[i], i, that1.Id[i]) + } + } + if len(this.Value) != len(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", len(this.Value), len(that1.Value)) + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return fmt.Errorf("Value this[%v](%v) Not Equal that[%v](%v)", i, this.Value[i], i, that1.Value[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Id) != len(that1.Id) { + return false + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return false + } + } + if len(this.Value) != len(that1.Value) { + return false + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepCustom) + if !ok { + return fmt.Errorf("that is not of type *NinRepCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepCustombut is not nil && this == nil") + } + if len(this.Id) != len(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", len(this.Id), len(that1.Id)) + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return fmt.Errorf("Id this[%v](%v) Not Equal that[%v](%v)", i, this.Id[i], i, that1.Id[i]) + } + } + if len(this.Value) != len(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", len(this.Value), len(that1.Value)) + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return fmt.Errorf("Value this[%v](%v) Not Equal that[%v](%v)", i, this.Value[i], i, that1.Value[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Id) != len(that1.Id) { + return false + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return false + } + } + if len(this.Value) != len(that1.Value) { + return false + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNativeUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNativeUnion) + if !ok { + return fmt.Errorf("that is not of type *NinOptNativeUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNativeUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativeUnionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNativeUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNativeUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinOptStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptStructUnionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !this.Field4.Equal(that1.Field4) { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinEmbeddedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinEmbeddedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinEmbeddedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinEmbeddedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinEmbeddedStructUnionbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", *this.Field210, *that1.Field210) + } + } else if this.Field210 != nil { + return fmt.Errorf("this.Field210 == nil && that.Field210 != nil") + } else if that1.Field210 != nil { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinEmbeddedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinEmbeddedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(that1.Field200) { + return false + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return false + } + } else if this.Field210 != nil { + return false + } else if that1.Field210 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinNestedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinNestedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinNestedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinNestedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinNestedStructUnionbut is not nil && this == nil") + } + if !this.Field1.Equal(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !this.Field2.Equal(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinNestedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinNestedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(that1.Field1) { + return false + } + if !this.Field2.Equal(that1.Field2) { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Tree) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Tree) + if !ok { + return fmt.Errorf("that is not of type *Tree") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Tree but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Treebut is not nil && this == nil") + } + if !this.Or.Equal(that1.Or) { + return fmt.Errorf("Or this(%v) Not Equal that(%v)", this.Or, that1.Or) + } + if !this.And.Equal(that1.And) { + return fmt.Errorf("And this(%v) Not Equal that(%v)", this.And, that1.And) + } + if !this.Leaf.Equal(that1.Leaf) { + return fmt.Errorf("Leaf this(%v) Not Equal that(%v)", this.Leaf, that1.Leaf) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Tree) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Tree) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Or.Equal(that1.Or) { + return false + } + if !this.And.Equal(that1.And) { + return false + } + if !this.Leaf.Equal(that1.Leaf) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OrBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OrBranch) + if !ok { + return fmt.Errorf("that is not of type *OrBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OrBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OrBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OrBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OrBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AndBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AndBranch) + if !ok { + return fmt.Errorf("that is not of type *AndBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AndBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AndBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AndBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AndBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Leaf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Leaf) + if !ok { + return fmt.Errorf("that is not of type *Leaf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Leaf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Leafbut is not nil && this == nil") + } + if this.Value != that1.Value { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if this.StrValue != that1.StrValue { + return fmt.Errorf("StrValue this(%v) Not Equal that(%v)", this.StrValue, that1.StrValue) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Leaf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Leaf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Value != that1.Value { + return false + } + if this.StrValue != that1.StrValue { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *DeepTree) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*DeepTree) + if !ok { + return fmt.Errorf("that is not of type *DeepTree") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *DeepTree but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *DeepTreebut is not nil && this == nil") + } + if !this.Down.Equal(that1.Down) { + return fmt.Errorf("Down this(%v) Not Equal that(%v)", this.Down, that1.Down) + } + if !this.And.Equal(that1.And) { + return fmt.Errorf("And this(%v) Not Equal that(%v)", this.And, that1.And) + } + if !this.Leaf.Equal(that1.Leaf) { + return fmt.Errorf("Leaf this(%v) Not Equal that(%v)", this.Leaf, that1.Leaf) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *DeepTree) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*DeepTree) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Down.Equal(that1.Down) { + return false + } + if !this.And.Equal(that1.And) { + return false + } + if !this.Leaf.Equal(that1.Leaf) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *ADeepBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*ADeepBranch) + if !ok { + return fmt.Errorf("that is not of type *ADeepBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *ADeepBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *ADeepBranchbut is not nil && this == nil") + } + if !this.Down.Equal(&that1.Down) { + return fmt.Errorf("Down this(%v) Not Equal that(%v)", this.Down, that1.Down) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *ADeepBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*ADeepBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Down.Equal(&that1.Down) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AndDeepBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AndDeepBranch) + if !ok { + return fmt.Errorf("that is not of type *AndDeepBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AndDeepBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AndDeepBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AndDeepBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AndDeepBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *DeepLeaf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*DeepLeaf) + if !ok { + return fmt.Errorf("that is not of type *DeepLeaf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *DeepLeaf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *DeepLeafbut is not nil && this == nil") + } + if !this.Tree.Equal(&that1.Tree) { + return fmt.Errorf("Tree this(%v) Not Equal that(%v)", this.Tree, that1.Tree) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *DeepLeaf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*DeepLeaf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Tree.Equal(&that1.Tree) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Nil) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Nil) + if !ok { + return fmt.Errorf("that is not of type *Nil") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Nil but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Nilbut is not nil && this == nil") + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Nil) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Nil) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptEnum) + if !ok { + return fmt.Errorf("that is not of type *NidOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptEnumbut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptEnum) + if !ok { + return fmt.Errorf("that is not of type *NinOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptEnumbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepEnum) + if !ok { + return fmt.Errorf("that is not of type *NidRepEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepEnumbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepEnum) + if !ok { + return fmt.Errorf("that is not of type *NinRepEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepEnumbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptEnumDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptEnumDefault) + if !ok { + return fmt.Errorf("that is not of type *NinOptEnumDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptEnumDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptEnumDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptEnumDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptEnumDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AnotherNinOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AnotherNinOptEnum) + if !ok { + return fmt.Errorf("that is not of type *AnotherNinOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AnotherNinOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AnotherNinOptEnumbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AnotherNinOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AnotherNinOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AnotherNinOptEnumDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AnotherNinOptEnumDefault) + if !ok { + return fmt.Errorf("that is not of type *AnotherNinOptEnumDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AnotherNinOptEnumDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AnotherNinOptEnumDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AnotherNinOptEnumDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AnotherNinOptEnumDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Timer) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Timer) + if !ok { + return fmt.Errorf("that is not of type *Timer") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Timer but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Timerbut is not nil && this == nil") + } + if this.Time1 != that1.Time1 { + return fmt.Errorf("Time1 this(%v) Not Equal that(%v)", this.Time1, that1.Time1) + } + if this.Time2 != that1.Time2 { + return fmt.Errorf("Time2 this(%v) Not Equal that(%v)", this.Time2, that1.Time2) + } + if !bytes.Equal(this.Data, that1.Data) { + return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Timer) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Timer) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Time1 != that1.Time1 { + return false + } + if this.Time2 != that1.Time2 { + return false + } + if !bytes.Equal(this.Data, that1.Data) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *MyExtendable) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*MyExtendable) + if !ok { + return fmt.Errorf("that is not of type *MyExtendable") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *MyExtendable but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *MyExtendablebut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return fmt.Errorf("XXX_extensions this[%v](%v) Not Equal that[%v](%v)", k, this.XXX_extensions[k], k, that1.XXX_extensions[k]) + } + } else { + return fmt.Errorf("XXX_extensions[%v] Not In that", k) + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return fmt.Errorf("XXX_extensions[%v] Not In this", k) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *MyExtendable) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*MyExtendable) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return false + } + } else { + return false + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OtherExtenable) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OtherExtenable) + if !ok { + return fmt.Errorf("that is not of type *OtherExtenable") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OtherExtenable but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OtherExtenablebut is not nil && this == nil") + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if !this.M.Equal(that1.M) { + return fmt.Errorf("M this(%v) Not Equal that(%v)", this.M, that1.M) + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return fmt.Errorf("XXX_extensions this[%v](%v) Not Equal that[%v](%v)", k, this.XXX_extensions[k], k, that1.XXX_extensions[k]) + } + } else { + return fmt.Errorf("XXX_extensions[%v] Not In that", k) + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return fmt.Errorf("XXX_extensions[%v] Not In this", k) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OtherExtenable) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OtherExtenable) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if !this.M.Equal(that1.M) { + return false + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return false + } + } else { + return false + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinitionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.EnumField != nil && that1.EnumField != nil { + if *this.EnumField != *that1.EnumField { + return fmt.Errorf("EnumField this(%v) Not Equal that(%v)", *this.EnumField, *that1.EnumField) + } + } else if this.EnumField != nil { + return fmt.Errorf("this.EnumField == nil && that.EnumField != nil") + } else if that1.EnumField != nil { + return fmt.Errorf("EnumField this(%v) Not Equal that(%v)", this.EnumField, that1.EnumField) + } + if !this.NNM.Equal(that1.NNM) { + return fmt.Errorf("NNM this(%v) Not Equal that(%v)", this.NNM, that1.NNM) + } + if !this.NM.Equal(that1.NM) { + return fmt.Errorf("NM this(%v) Not Equal that(%v)", this.NM, that1.NM) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.EnumField != nil && that1.EnumField != nil { + if *this.EnumField != *that1.EnumField { + return false + } + } else if this.EnumField != nil { + return false + } else if that1.EnumField != nil { + return false + } + if !this.NNM.Equal(that1.NNM) { + return false + } + if !this.NM.Equal(that1.NM) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition_NestedMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition_NestedMessage) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition_NestedMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition_NestedMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinition_NestedMessagebut is not nil && this == nil") + } + if this.NestedField1 != nil && that1.NestedField1 != nil { + if *this.NestedField1 != *that1.NestedField1 { + return fmt.Errorf("NestedField1 this(%v) Not Equal that(%v)", *this.NestedField1, *that1.NestedField1) + } + } else if this.NestedField1 != nil { + return fmt.Errorf("this.NestedField1 == nil && that.NestedField1 != nil") + } else if that1.NestedField1 != nil { + return fmt.Errorf("NestedField1 this(%v) Not Equal that(%v)", this.NestedField1, that1.NestedField1) + } + if !this.NNM.Equal(that1.NNM) { + return fmt.Errorf("NNM this(%v) Not Equal that(%v)", this.NNM, that1.NNM) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition_NestedMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition_NestedMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.NestedField1 != nil && that1.NestedField1 != nil { + if *this.NestedField1 != *that1.NestedField1 { + return false + } + } else if this.NestedField1 != nil { + return false + } else if that1.NestedField1 != nil { + return false + } + if !this.NNM.Equal(that1.NNM) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition_NestedMessage_NestedNestedMsg) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition_NestedMessage_NestedNestedMsg") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition_NestedMessage_NestedNestedMsg but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinition_NestedMessage_NestedNestedMsgbut is not nil && this == nil") + } + if this.NestedNestedField1 != nil && that1.NestedNestedField1 != nil { + if *this.NestedNestedField1 != *that1.NestedNestedField1 { + return fmt.Errorf("NestedNestedField1 this(%v) Not Equal that(%v)", *this.NestedNestedField1, *that1.NestedNestedField1) + } + } else if this.NestedNestedField1 != nil { + return fmt.Errorf("this.NestedNestedField1 == nil && that.NestedNestedField1 != nil") + } else if that1.NestedNestedField1 != nil { + return fmt.Errorf("NestedNestedField1 this(%v) Not Equal that(%v)", this.NestedNestedField1, that1.NestedNestedField1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition_NestedMessage_NestedNestedMsg) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.NestedNestedField1 != nil && that1.NestedNestedField1 != nil { + if *this.NestedNestedField1 != *that1.NestedNestedField1 { + return false + } + } else if this.NestedNestedField1 != nil { + return false + } else if that1.NestedNestedField1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedScope) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedScope) + if !ok { + return fmt.Errorf("that is not of type *NestedScope") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedScope but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedScopebut is not nil && this == nil") + } + if !this.A.Equal(that1.A) { + return fmt.Errorf("A this(%v) Not Equal that(%v)", this.A, that1.A) + } + if this.B != nil && that1.B != nil { + if *this.B != *that1.B { + return fmt.Errorf("B this(%v) Not Equal that(%v)", *this.B, *that1.B) + } + } else if this.B != nil { + return fmt.Errorf("this.B == nil && that.B != nil") + } else if that1.B != nil { + return fmt.Errorf("B this(%v) Not Equal that(%v)", this.B, that1.B) + } + if !this.C.Equal(that1.C) { + return fmt.Errorf("C this(%v) Not Equal that(%v)", this.C, that1.C) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedScope) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedScope) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.A.Equal(that1.A) { + return false + } + if this.B != nil && that1.B != nil { + if *this.B != *that1.B { + return false + } + } else if this.B != nil { + return false + } else if that1.B != nil { + return false + } + if !this.C.Equal(that1.C) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNativeDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNativeDefault) + if !ok { + return fmt.Errorf("that is not of type *NinOptNativeDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNativeDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativeDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", *this.Field8, *that1.Field8) + } + } else if this.Field8 != nil { + return fmt.Errorf("this.Field8 == nil && that.Field8 != nil") + } else if that1.Field8 != nil { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", *this.Field9, *that1.Field9) + } + } else if this.Field9 != nil { + return fmt.Errorf("this.Field9 == nil && that.Field9 != nil") + } else if that1.Field9 != nil { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", *this.Field10, *that1.Field10) + } + } else if this.Field10 != nil { + return fmt.Errorf("this.Field10 == nil && that.Field10 != nil") + } else if that1.Field10 != nil { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", *this.Field11, *that1.Field11) + } + } else if this.Field11 != nil { + return fmt.Errorf("this.Field11 == nil && that.Field11 != nil") + } else if that1.Field11 != nil { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", *this.Field12, *that1.Field12) + } + } else if this.Field12 != nil { + return fmt.Errorf("this.Field12 == nil && that.Field12 != nil") + } else if that1.Field12 != nil { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNativeDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNativeDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return false + } + } else if this.Field8 != nil { + return false + } else if that1.Field8 != nil { + return false + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return false + } + } else if this.Field9 != nil { + return false + } else if that1.Field9 != nil { + return false + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return false + } + } else if this.Field10 != nil { + return false + } else if that1.Field10 != nil { + return false + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return false + } + } else if this.Field11 != nil { + return false + } else if that1.Field11 != nil { + return false + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return false + } + } else if this.Field12 != nil { + return false + } else if that1.Field12 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomContainer) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomContainer) + if !ok { + return fmt.Errorf("that is not of type *CustomContainer") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomContainer but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomContainerbut is not nil && this == nil") + } + if !this.CustomStruct.Equal(&that1.CustomStruct) { + return fmt.Errorf("CustomStruct this(%v) Not Equal that(%v)", this.CustomStruct, that1.CustomStruct) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomContainer) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomContainer) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.CustomStruct.Equal(&that1.CustomStruct) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNidOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNidOptNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNidOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNidOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNidOptNativebut is not nil && this == nil") + } + if this.FieldA != that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if this.FieldC != that1.FieldC { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if this.FieldD != that1.FieldD { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", this.FieldD, that1.FieldD) + } + if this.FieldE != that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if this.FieldG != that1.FieldG { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if this.FieldJ != that1.FieldJ { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if this.FieldK != that1.FieldK { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", this.FieldK, that1.FieldK) + } + if this.FieldL != that1.FieldL { + return fmt.Errorf("FieldL this(%v) Not Equal that(%v)", this.FieldL, that1.FieldL) + } + if this.FieldM != that1.FieldM { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", this.FieldM, that1.FieldM) + } + if this.FieldN != that1.FieldN { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", this.FieldN, that1.FieldN) + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", this.FieldO, that1.FieldO) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNidOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNidOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != that1.FieldA { + return false + } + if this.FieldB != that1.FieldB { + return false + } + if this.FieldC != that1.FieldC { + return false + } + if this.FieldD != that1.FieldD { + return false + } + if this.FieldE != that1.FieldE { + return false + } + if this.FieldF != that1.FieldF { + return false + } + if this.FieldG != that1.FieldG { + return false + } + if this.FieldH != that1.FieldH { + return false + } + if this.FieldI != that1.FieldI { + return false + } + if this.FieldJ != that1.FieldJ { + return false + } + if this.FieldK != that1.FieldK { + return false + } + if this.FieldL != that1.FieldL { + return false + } + if this.FieldM != that1.FieldM { + return false + } + if this.FieldN != that1.FieldN { + return false + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinOptNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinOptNativebut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if this.FieldC != nil && that1.FieldC != nil { + if *this.FieldC != *that1.FieldC { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", *this.FieldC, *that1.FieldC) + } + } else if this.FieldC != nil { + return fmt.Errorf("this.FieldC == nil && that.FieldC != nil") + } else if that1.FieldC != nil { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if this.FieldD != nil && that1.FieldD != nil { + if *this.FieldD != *that1.FieldD { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", *this.FieldD, *that1.FieldD) + } + } else if this.FieldD != nil { + return fmt.Errorf("this.FieldD == nil && that.FieldD != nil") + } else if that1.FieldD != nil { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", this.FieldD, that1.FieldD) + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", *this.FieldE, *that1.FieldE) + } + } else if this.FieldE != nil { + return fmt.Errorf("this.FieldE == nil && that.FieldE != nil") + } else if that1.FieldE != nil { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", *this.FieldF, *that1.FieldF) + } + } else if this.FieldF != nil { + return fmt.Errorf("this.FieldF == nil && that.FieldF != nil") + } else if that1.FieldF != nil { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if this.FieldG != nil && that1.FieldG != nil { + if *this.FieldG != *that1.FieldG { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", *this.FieldG, *that1.FieldG) + } + } else if this.FieldG != nil { + return fmt.Errorf("this.FieldG == nil && that.FieldG != nil") + } else if that1.FieldG != nil { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", *this.FieldH, *that1.FieldH) + } + } else if this.FieldH != nil { + return fmt.Errorf("this.FieldH == nil && that.FieldH != nil") + } else if that1.FieldH != nil { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", *this.FieldI, *that1.FieldI) + } + } else if this.FieldI != nil { + return fmt.Errorf("this.FieldI == nil && that.FieldI != nil") + } else if that1.FieldI != nil { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if this.FieldJ != nil && that1.FieldJ != nil { + if *this.FieldJ != *that1.FieldJ { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", *this.FieldJ, *that1.FieldJ) + } + } else if this.FieldJ != nil { + return fmt.Errorf("this.FieldJ == nil && that.FieldJ != nil") + } else if that1.FieldJ != nil { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if this.FieldK != nil && that1.FieldK != nil { + if *this.FieldK != *that1.FieldK { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", *this.FieldK, *that1.FieldK) + } + } else if this.FieldK != nil { + return fmt.Errorf("this.FieldK == nil && that.FieldK != nil") + } else if that1.FieldK != nil { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", this.FieldK, that1.FieldK) + } + if this.FielL != nil && that1.FielL != nil { + if *this.FielL != *that1.FielL { + return fmt.Errorf("FielL this(%v) Not Equal that(%v)", *this.FielL, *that1.FielL) + } + } else if this.FielL != nil { + return fmt.Errorf("this.FielL == nil && that.FielL != nil") + } else if that1.FielL != nil { + return fmt.Errorf("FielL this(%v) Not Equal that(%v)", this.FielL, that1.FielL) + } + if this.FieldM != nil && that1.FieldM != nil { + if *this.FieldM != *that1.FieldM { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", *this.FieldM, *that1.FieldM) + } + } else if this.FieldM != nil { + return fmt.Errorf("this.FieldM == nil && that.FieldM != nil") + } else if that1.FieldM != nil { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", this.FieldM, that1.FieldM) + } + if this.FieldN != nil && that1.FieldN != nil { + if *this.FieldN != *that1.FieldN { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", *this.FieldN, *that1.FieldN) + } + } else if this.FieldN != nil { + return fmt.Errorf("this.FieldN == nil && that.FieldN != nil") + } else if that1.FieldN != nil { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", this.FieldN, that1.FieldN) + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", this.FieldO, that1.FieldO) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if this.FieldC != nil && that1.FieldC != nil { + if *this.FieldC != *that1.FieldC { + return false + } + } else if this.FieldC != nil { + return false + } else if that1.FieldC != nil { + return false + } + if this.FieldD != nil && that1.FieldD != nil { + if *this.FieldD != *that1.FieldD { + return false + } + } else if this.FieldD != nil { + return false + } else if that1.FieldD != nil { + return false + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return false + } + } else if this.FieldE != nil { + return false + } else if that1.FieldE != nil { + return false + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return false + } + } else if this.FieldF != nil { + return false + } else if that1.FieldF != nil { + return false + } + if this.FieldG != nil && that1.FieldG != nil { + if *this.FieldG != *that1.FieldG { + return false + } + } else if this.FieldG != nil { + return false + } else if that1.FieldG != nil { + return false + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return false + } + } else if this.FieldH != nil { + return false + } else if that1.FieldH != nil { + return false + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return false + } + } else if this.FieldI != nil { + return false + } else if that1.FieldI != nil { + return false + } + if this.FieldJ != nil && that1.FieldJ != nil { + if *this.FieldJ != *that1.FieldJ { + return false + } + } else if this.FieldJ != nil { + return false + } else if that1.FieldJ != nil { + return false + } + if this.FieldK != nil && that1.FieldK != nil { + if *this.FieldK != *that1.FieldK { + return false + } + } else if this.FieldK != nil { + return false + } else if that1.FieldK != nil { + return false + } + if this.FielL != nil && that1.FielL != nil { + if *this.FielL != *that1.FielL { + return false + } + } else if this.FielL != nil { + return false + } else if that1.FielL != nil { + return false + } + if this.FieldM != nil && that1.FieldM != nil { + if *this.FieldM != *that1.FieldM { + return false + } + } else if this.FieldM != nil { + return false + } else if that1.FieldM != nil { + return false + } + if this.FieldN != nil && that1.FieldN != nil { + if *this.FieldN != *that1.FieldN { + return false + } + } else if this.FieldN != nil { + return false + } else if that1.FieldN != nil { + return false + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinRepNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinRepNativebut is not nil && this == nil") + } + if len(this.FieldA) != len(that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", len(this.FieldA), len(that1.FieldA)) + } + for i := range this.FieldA { + if this.FieldA[i] != that1.FieldA[i] { + return fmt.Errorf("FieldA this[%v](%v) Not Equal that[%v](%v)", i, this.FieldA[i], i, that1.FieldA[i]) + } + } + if len(this.FieldB) != len(that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", len(this.FieldB), len(that1.FieldB)) + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return fmt.Errorf("FieldB this[%v](%v) Not Equal that[%v](%v)", i, this.FieldB[i], i, that1.FieldB[i]) + } + } + if len(this.FieldC) != len(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", len(this.FieldC), len(that1.FieldC)) + } + for i := range this.FieldC { + if this.FieldC[i] != that1.FieldC[i] { + return fmt.Errorf("FieldC this[%v](%v) Not Equal that[%v](%v)", i, this.FieldC[i], i, that1.FieldC[i]) + } + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if this.FieldD[i] != that1.FieldD[i] { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if len(this.FieldE) != len(that1.FieldE) { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", len(this.FieldE), len(that1.FieldE)) + } + for i := range this.FieldE { + if this.FieldE[i] != that1.FieldE[i] { + return fmt.Errorf("FieldE this[%v](%v) Not Equal that[%v](%v)", i, this.FieldE[i], i, that1.FieldE[i]) + } + } + if len(this.FieldF) != len(that1.FieldF) { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", len(this.FieldF), len(that1.FieldF)) + } + for i := range this.FieldF { + if this.FieldF[i] != that1.FieldF[i] { + return fmt.Errorf("FieldF this[%v](%v) Not Equal that[%v](%v)", i, this.FieldF[i], i, that1.FieldF[i]) + } + } + if len(this.FieldG) != len(that1.FieldG) { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", len(this.FieldG), len(that1.FieldG)) + } + for i := range this.FieldG { + if this.FieldG[i] != that1.FieldG[i] { + return fmt.Errorf("FieldG this[%v](%v) Not Equal that[%v](%v)", i, this.FieldG[i], i, that1.FieldG[i]) + } + } + if len(this.FieldH) != len(that1.FieldH) { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", len(this.FieldH), len(that1.FieldH)) + } + for i := range this.FieldH { + if this.FieldH[i] != that1.FieldH[i] { + return fmt.Errorf("FieldH this[%v](%v) Not Equal that[%v](%v)", i, this.FieldH[i], i, that1.FieldH[i]) + } + } + if len(this.FieldI) != len(that1.FieldI) { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", len(this.FieldI), len(that1.FieldI)) + } + for i := range this.FieldI { + if this.FieldI[i] != that1.FieldI[i] { + return fmt.Errorf("FieldI this[%v](%v) Not Equal that[%v](%v)", i, this.FieldI[i], i, that1.FieldI[i]) + } + } + if len(this.FieldJ) != len(that1.FieldJ) { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", len(this.FieldJ), len(that1.FieldJ)) + } + for i := range this.FieldJ { + if this.FieldJ[i] != that1.FieldJ[i] { + return fmt.Errorf("FieldJ this[%v](%v) Not Equal that[%v](%v)", i, this.FieldJ[i], i, that1.FieldJ[i]) + } + } + if len(this.FieldK) != len(that1.FieldK) { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", len(this.FieldK), len(that1.FieldK)) + } + for i := range this.FieldK { + if this.FieldK[i] != that1.FieldK[i] { + return fmt.Errorf("FieldK this[%v](%v) Not Equal that[%v](%v)", i, this.FieldK[i], i, that1.FieldK[i]) + } + } + if len(this.FieldL) != len(that1.FieldL) { + return fmt.Errorf("FieldL this(%v) Not Equal that(%v)", len(this.FieldL), len(that1.FieldL)) + } + for i := range this.FieldL { + if this.FieldL[i] != that1.FieldL[i] { + return fmt.Errorf("FieldL this[%v](%v) Not Equal that[%v](%v)", i, this.FieldL[i], i, that1.FieldL[i]) + } + } + if len(this.FieldM) != len(that1.FieldM) { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", len(this.FieldM), len(that1.FieldM)) + } + for i := range this.FieldM { + if this.FieldM[i] != that1.FieldM[i] { + return fmt.Errorf("FieldM this[%v](%v) Not Equal that[%v](%v)", i, this.FieldM[i], i, that1.FieldM[i]) + } + } + if len(this.FieldN) != len(that1.FieldN) { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", len(this.FieldN), len(that1.FieldN)) + } + for i := range this.FieldN { + if this.FieldN[i] != that1.FieldN[i] { + return fmt.Errorf("FieldN this[%v](%v) Not Equal that[%v](%v)", i, this.FieldN[i], i, that1.FieldN[i]) + } + } + if len(this.FieldO) != len(that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", len(this.FieldO), len(that1.FieldO)) + } + for i := range this.FieldO { + if !bytes.Equal(this.FieldO[i], that1.FieldO[i]) { + return fmt.Errorf("FieldO this[%v](%v) Not Equal that[%v](%v)", i, this.FieldO[i], i, that1.FieldO[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.FieldA) != len(that1.FieldA) { + return false + } + for i := range this.FieldA { + if this.FieldA[i] != that1.FieldA[i] { + return false + } + } + if len(this.FieldB) != len(that1.FieldB) { + return false + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return false + } + } + if len(this.FieldC) != len(that1.FieldC) { + return false + } + for i := range this.FieldC { + if this.FieldC[i] != that1.FieldC[i] { + return false + } + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if this.FieldD[i] != that1.FieldD[i] { + return false + } + } + if len(this.FieldE) != len(that1.FieldE) { + return false + } + for i := range this.FieldE { + if this.FieldE[i] != that1.FieldE[i] { + return false + } + } + if len(this.FieldF) != len(that1.FieldF) { + return false + } + for i := range this.FieldF { + if this.FieldF[i] != that1.FieldF[i] { + return false + } + } + if len(this.FieldG) != len(that1.FieldG) { + return false + } + for i := range this.FieldG { + if this.FieldG[i] != that1.FieldG[i] { + return false + } + } + if len(this.FieldH) != len(that1.FieldH) { + return false + } + for i := range this.FieldH { + if this.FieldH[i] != that1.FieldH[i] { + return false + } + } + if len(this.FieldI) != len(that1.FieldI) { + return false + } + for i := range this.FieldI { + if this.FieldI[i] != that1.FieldI[i] { + return false + } + } + if len(this.FieldJ) != len(that1.FieldJ) { + return false + } + for i := range this.FieldJ { + if this.FieldJ[i] != that1.FieldJ[i] { + return false + } + } + if len(this.FieldK) != len(that1.FieldK) { + return false + } + for i := range this.FieldK { + if this.FieldK[i] != that1.FieldK[i] { + return false + } + } + if len(this.FieldL) != len(that1.FieldL) { + return false + } + for i := range this.FieldL { + if this.FieldL[i] != that1.FieldL[i] { + return false + } + } + if len(this.FieldM) != len(that1.FieldM) { + return false + } + for i := range this.FieldM { + if this.FieldM[i] != that1.FieldM[i] { + return false + } + } + if len(this.FieldN) != len(that1.FieldN) { + return false + } + for i := range this.FieldN { + if this.FieldN[i] != that1.FieldN[i] { + return false + } + } + if len(this.FieldO) != len(that1.FieldO) { + return false + } + for i := range this.FieldO { + if !bytes.Equal(this.FieldO[i], that1.FieldO[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinStruct) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinStructbut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if !this.FieldC.Equal(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", *this.FieldE, *that1.FieldE) + } + } else if this.FieldE != nil { + return fmt.Errorf("this.FieldE == nil && that.FieldE != nil") + } else if that1.FieldE != nil { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", *this.FieldF, *that1.FieldF) + } + } else if this.FieldF != nil { + return fmt.Errorf("this.FieldF == nil && that.FieldF != nil") + } else if that1.FieldF != nil { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if !this.FieldG.Equal(that1.FieldG) { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", *this.FieldH, *that1.FieldH) + } + } else if this.FieldH != nil { + return fmt.Errorf("this.FieldH == nil && that.FieldH != nil") + } else if that1.FieldH != nil { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", *this.FieldI, *that1.FieldI) + } + } else if this.FieldI != nil { + return fmt.Errorf("this.FieldI == nil && that.FieldI != nil") + } else if that1.FieldI != nil { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if !bytes.Equal(this.FieldJ, that1.FieldJ) { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if !this.FieldC.Equal(that1.FieldC) { + return false + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return false + } + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return false + } + } else if this.FieldE != nil { + return false + } else if that1.FieldE != nil { + return false + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return false + } + } else if this.FieldF != nil { + return false + } else if that1.FieldF != nil { + return false + } + if !this.FieldG.Equal(that1.FieldG) { + return false + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return false + } + } else if this.FieldH != nil { + return false + } else if that1.FieldH != nil { + return false + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return false + } + } else if this.FieldI != nil { + return false + } else if that1.FieldI != nil { + return false + } + if !bytes.Equal(this.FieldJ, that1.FieldJ) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameCustomType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameCustomType) + if !ok { + return fmt.Errorf("that is not of type *CustomNameCustomType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameCustomType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameCustomTypebut is not nil && this == nil") + } + if that1.FieldA == nil { + if this.FieldA != nil { + return fmt.Errorf("this.FieldA != nil && that1.FieldA == nil") + } + } else if !this.FieldA.Equal(*that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if that1.FieldB == nil { + if this.FieldB != nil { + return fmt.Errorf("this.FieldB != nil && that1.FieldB == nil") + } + } else if !this.FieldB.Equal(*that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if len(this.FieldC) != len(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", len(this.FieldC), len(that1.FieldC)) + } + for i := range this.FieldC { + if !this.FieldC[i].Equal(that1.FieldC[i]) { + return fmt.Errorf("FieldC this[%v](%v) Not Equal that[%v](%v)", i, this.FieldC[i], i, that1.FieldC[i]) + } + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameCustomType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameCustomType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.FieldA == nil { + if this.FieldA != nil { + return false + } + } else if !this.FieldA.Equal(*that1.FieldA) { + return false + } + if that1.FieldB == nil { + if this.FieldB != nil { + return false + } + } else if !this.FieldB.Equal(*that1.FieldB) { + return false + } + if len(this.FieldC) != len(that1.FieldC) { + return false + } + for i := range this.FieldC { + if !this.FieldC[i].Equal(that1.FieldC[i]) { + return false + } + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinEmbeddedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinEmbeddedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinEmbeddedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinEmbeddedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinEmbeddedStructUnionbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.FieldA.Equal(that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinEmbeddedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinEmbeddedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.FieldA.Equal(that1.FieldA) { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameEnum) + if !ok { + return fmt.Errorf("that is not of type *CustomNameEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameEnumbut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if len(this.FieldB) != len(that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", len(this.FieldB), len(that1.FieldB)) + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return fmt.Errorf("FieldB this[%v](%v) Not Equal that[%v](%v)", i, this.FieldB[i], i, that1.FieldB[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if len(this.FieldB) != len(that1.FieldB) { + return false + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NoExtensionsMap) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NoExtensionsMap) + if !ok { + return fmt.Errorf("that is not of type *NoExtensionsMap") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NoExtensionsMap but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NoExtensionsMapbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) { + return fmt.Errorf("XXX_extensions this(%v) Not Equal that(%v)", this.XXX_extensions, that1.XXX_extensions) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NoExtensionsMap) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NoExtensionsMap) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Unrecognized) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Unrecognized) + if !ok { + return fmt.Errorf("that is not of type *Unrecognized") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Unrecognized but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Unrecognizedbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *Unrecognized) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Unrecognized) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} +func (this *UnrecognizedWithInner) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithInner) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithInner") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithInner but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithInnerbut is not nil && this == nil") + } + if len(this.Embedded) != len(that1.Embedded) { + return fmt.Errorf("Embedded this(%v) Not Equal that(%v)", len(this.Embedded), len(that1.Embedded)) + } + for i := range this.Embedded { + if !this.Embedded[i].Equal(that1.Embedded[i]) { + return fmt.Errorf("Embedded this[%v](%v) Not Equal that[%v](%v)", i, this.Embedded[i], i, that1.Embedded[i]) + } + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *UnrecognizedWithInner) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithInner) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Embedded) != len(that1.Embedded) { + return false + } + for i := range this.Embedded { + if !this.Embedded[i].Equal(that1.Embedded[i]) { + return false + } + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *UnrecognizedWithInner_Inner) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithInner_Inner) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithInner_Inner") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithInner_Inner but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithInner_Innerbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *UnrecognizedWithInner_Inner) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithInner_Inner) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} +func (this *UnrecognizedWithEmbed) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithEmbed) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithEmbed") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithEmbed but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithEmbedbut is not nil && this == nil") + } + if !this.UnrecognizedWithEmbed_Embedded.Equal(&that1.UnrecognizedWithEmbed_Embedded) { + return fmt.Errorf("UnrecognizedWithEmbed_Embedded this(%v) Not Equal that(%v)", this.UnrecognizedWithEmbed_Embedded, that1.UnrecognizedWithEmbed_Embedded) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *UnrecognizedWithEmbed) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithEmbed) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.UnrecognizedWithEmbed_Embedded.Equal(&that1.UnrecognizedWithEmbed_Embedded) { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *UnrecognizedWithEmbed_Embedded) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithEmbed_Embedded) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithEmbed_Embedded") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithEmbed_Embedded but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithEmbed_Embeddedbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *UnrecognizedWithEmbed_Embedded) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithEmbed_Embedded) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} + +type NidOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() float64 + GetField2() float32 + GetField3() int32 + GetField4() int64 + GetField5() uint32 + GetField6() uint64 + GetField7() int32 + GetField8() int64 + GetField9() uint32 + GetField10() int32 + GetField11() uint64 + GetField12() int64 + GetField13() bool + GetField14() string + GetField15() []byte +} + +func (this *NidOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptNativeFromFace(this) +} + +func (this *NidOptNative) GetField1() float64 { + return this.Field1 +} + +func (this *NidOptNative) GetField2() float32 { + return this.Field2 +} + +func (this *NidOptNative) GetField3() int32 { + return this.Field3 +} + +func (this *NidOptNative) GetField4() int64 { + return this.Field4 +} + +func (this *NidOptNative) GetField5() uint32 { + return this.Field5 +} + +func (this *NidOptNative) GetField6() uint64 { + return this.Field6 +} + +func (this *NidOptNative) GetField7() int32 { + return this.Field7 +} + +func (this *NidOptNative) GetField8() int64 { + return this.Field8 +} + +func (this *NidOptNative) GetField9() uint32 { + return this.Field9 +} + +func (this *NidOptNative) GetField10() int32 { + return this.Field10 +} + +func (this *NidOptNative) GetField11() uint64 { + return this.Field11 +} + +func (this *NidOptNative) GetField12() int64 { + return this.Field12 +} + +func (this *NidOptNative) GetField13() bool { + return this.Field13 +} + +func (this *NidOptNative) GetField14() string { + return this.Field14 +} + +func (this *NidOptNative) GetField15() []byte { + return this.Field15 +} + +func NewNidOptNativeFromFace(that NidOptNativeFace) *NidOptNative { + this := &NidOptNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *int32 + GetField4() *int64 + GetField5() *uint32 + GetField6() *uint64 + GetField7() *int32 + GetField8() *int64 + GetField9() *uint32 + GetField10() *int32 + GetField11() *uint64 + GetField12() *int64 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptNativeFromFace(this) +} + +func (this *NinOptNative) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptNative) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptNative) GetField3() *int32 { + return this.Field3 +} + +func (this *NinOptNative) GetField4() *int64 { + return this.Field4 +} + +func (this *NinOptNative) GetField5() *uint32 { + return this.Field5 +} + +func (this *NinOptNative) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptNative) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptNative) GetField8() *int64 { + return this.Field8 +} + +func (this *NinOptNative) GetField9() *uint32 { + return this.Field9 +} + +func (this *NinOptNative) GetField10() *int32 { + return this.Field10 +} + +func (this *NinOptNative) GetField11() *uint64 { + return this.Field11 +} + +func (this *NinOptNative) GetField12() *int64 { + return this.Field12 +} + +func (this *NinOptNative) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptNative) GetField14() *string { + return this.Field14 +} + +func (this *NinOptNative) GetField15() []byte { + return this.Field15 +} + +func NewNinOptNativeFromFace(that NinOptNativeFace) *NinOptNative { + this := &NinOptNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NidRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepNativeFromFace(this) +} + +func (this *NidRepNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NidRepNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NidRepNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NidRepNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NidRepNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NidRepNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NidRepNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NidRepNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NidRepNative) GetField13() []bool { + return this.Field13 +} + +func (this *NidRepNative) GetField14() []string { + return this.Field14 +} + +func (this *NidRepNative) GetField15() [][]byte { + return this.Field15 +} + +func NewNidRepNativeFromFace(that NidRepNativeFace) *NidRepNative { + this := &NidRepNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NinRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepNativeFromFace(this) +} + +func (this *NinRepNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NinRepNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NinRepNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NinRepNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NinRepNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NinRepNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NinRepNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NinRepNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NinRepNative) GetField13() []bool { + return this.Field13 +} + +func (this *NinRepNative) GetField14() []string { + return this.Field14 +} + +func (this *NinRepNative) GetField15() [][]byte { + return this.Field15 +} + +func NewNinRepNativeFromFace(that NinRepNativeFace) *NinRepNative { + this := &NinRepNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepPackedNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool +} + +func (this *NidRepPackedNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepPackedNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepPackedNativeFromFace(this) +} + +func (this *NidRepPackedNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepPackedNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepPackedNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NidRepPackedNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NidRepPackedNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NidRepPackedNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepPackedNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepPackedNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NidRepPackedNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NidRepPackedNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NidRepPackedNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NidRepPackedNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NidRepPackedNative) GetField13() []bool { + return this.Field13 +} + +func NewNidRepPackedNativeFromFace(that NidRepPackedNativeFace) *NidRepPackedNative { + this := &NidRepPackedNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + return this +} + +type NinRepPackedNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool +} + +func (this *NinRepPackedNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepPackedNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepPackedNativeFromFace(this) +} + +func (this *NinRepPackedNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepPackedNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepPackedNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NinRepPackedNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NinRepPackedNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NinRepPackedNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepPackedNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepPackedNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NinRepPackedNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NinRepPackedNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NinRepPackedNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NinRepPackedNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NinRepPackedNative) GetField13() []bool { + return this.Field13 +} + +func NewNinRepPackedNativeFromFace(that NinRepPackedNativeFace) *NinRepPackedNative { + this := &NinRepPackedNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + return this +} + +type NidOptStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() float64 + GetField2() float32 + GetField3() NidOptNative + GetField4() NinOptNative + GetField6() uint64 + GetField7() int32 + GetField8() NidOptNative + GetField13() bool + GetField14() string + GetField15() []byte +} + +func (this *NidOptStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptStructFromFace(this) +} + +func (this *NidOptStruct) GetField1() float64 { + return this.Field1 +} + +func (this *NidOptStruct) GetField2() float32 { + return this.Field2 +} + +func (this *NidOptStruct) GetField3() NidOptNative { + return this.Field3 +} + +func (this *NidOptStruct) GetField4() NinOptNative { + return this.Field4 +} + +func (this *NidOptStruct) GetField6() uint64 { + return this.Field6 +} + +func (this *NidOptStruct) GetField7() int32 { + return this.Field7 +} + +func (this *NidOptStruct) GetField8() NidOptNative { + return this.Field8 +} + +func (this *NidOptStruct) GetField13() bool { + return this.Field13 +} + +func (this *NidOptStruct) GetField14() string { + return this.Field14 +} + +func (this *NidOptStruct) GetField15() []byte { + return this.Field15 +} + +func NewNidOptStructFromFace(that NidOptStructFace) *NidOptStruct { + this := &NidOptStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *NidOptNative + GetField4() *NinOptNative + GetField6() *uint64 + GetField7() *int32 + GetField8() *NidOptNative + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptStructFromFace(this) +} + +func (this *NinOptStruct) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptStruct) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptStruct) GetField3() *NidOptNative { + return this.Field3 +} + +func (this *NinOptStruct) GetField4() *NinOptNative { + return this.Field4 +} + +func (this *NinOptStruct) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptStruct) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptStruct) GetField8() *NidOptNative { + return this.Field8 +} + +func (this *NinOptStruct) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptStruct) GetField14() *string { + return this.Field14 +} + +func (this *NinOptStruct) GetField15() []byte { + return this.Field15 +} + +func NewNinOptStructFromFace(that NinOptStructFace) *NinOptStruct { + this := &NinOptStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []NidOptNative + GetField4() []NinOptNative + GetField6() []uint64 + GetField7() []int32 + GetField8() []NidOptNative + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NidRepStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepStructFromFace(this) +} + +func (this *NidRepStruct) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepStruct) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepStruct) GetField3() []NidOptNative { + return this.Field3 +} + +func (this *NidRepStruct) GetField4() []NinOptNative { + return this.Field4 +} + +func (this *NidRepStruct) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepStruct) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepStruct) GetField8() []NidOptNative { + return this.Field8 +} + +func (this *NidRepStruct) GetField13() []bool { + return this.Field13 +} + +func (this *NidRepStruct) GetField14() []string { + return this.Field14 +} + +func (this *NidRepStruct) GetField15() [][]byte { + return this.Field15 +} + +func NewNidRepStructFromFace(that NidRepStructFace) *NidRepStruct { + this := &NidRepStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinRepStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []*NidOptNative + GetField4() []*NinOptNative + GetField6() []uint64 + GetField7() []int32 + GetField8() []*NidOptNative + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NinRepStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepStructFromFace(this) +} + +func (this *NinRepStruct) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepStruct) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepStruct) GetField3() []*NidOptNative { + return this.Field3 +} + +func (this *NinRepStruct) GetField4() []*NinOptNative { + return this.Field4 +} + +func (this *NinRepStruct) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepStruct) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepStruct) GetField8() []*NidOptNative { + return this.Field8 +} + +func (this *NinRepStruct) GetField13() []bool { + return this.Field13 +} + +func (this *NinRepStruct) GetField14() []string { + return this.Field14 +} + +func (this *NinRepStruct) GetField15() [][]byte { + return this.Field15 +} + +func NewNinRepStructFromFace(that NinRepStructFace) *NinRepStruct { + this := &NinRepStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidEmbeddedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() NidOptNative + GetField210() bool +} + +func (this *NidEmbeddedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidEmbeddedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidEmbeddedStructFromFace(this) +} + +func (this *NidEmbeddedStruct) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NidEmbeddedStruct) GetField200() NidOptNative { + return this.Field200 +} + +func (this *NidEmbeddedStruct) GetField210() bool { + return this.Field210 +} + +func NewNidEmbeddedStructFromFace(that NidEmbeddedStructFace) *NidEmbeddedStruct { + this := &NidEmbeddedStruct{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NinEmbeddedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() *NidOptNative + GetField210() *bool +} + +func (this *NinEmbeddedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinEmbeddedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinEmbeddedStructFromFace(this) +} + +func (this *NinEmbeddedStruct) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NinEmbeddedStruct) GetField200() *NidOptNative { + return this.Field200 +} + +func (this *NinEmbeddedStruct) GetField210() *bool { + return this.Field210 +} + +func NewNinEmbeddedStructFromFace(that NinEmbeddedStructFace) *NinEmbeddedStruct { + this := &NinEmbeddedStruct{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NidNestedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() NidOptStruct + GetField2() []NidRepStruct +} + +func (this *NidNestedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidNestedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidNestedStructFromFace(this) +} + +func (this *NidNestedStruct) GetField1() NidOptStruct { + return this.Field1 +} + +func (this *NidNestedStruct) GetField2() []NidRepStruct { + return this.Field2 +} + +func NewNidNestedStructFromFace(that NidNestedStructFace) *NidNestedStruct { + this := &NidNestedStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + return this +} + +type NinNestedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *NinOptStruct + GetField2() []*NinRepStruct +} + +func (this *NinNestedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinNestedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinNestedStructFromFace(this) +} + +func (this *NinNestedStruct) GetField1() *NinOptStruct { + return this.Field1 +} + +func (this *NinNestedStruct) GetField2() []*NinRepStruct { + return this.Field2 +} + +func NewNinNestedStructFromFace(that NinNestedStructFace) *NinNestedStruct { + this := &NinNestedStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + return this +} + +type NidOptCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() Uuid + GetValue() github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NidOptCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptCustomFromFace(this) +} + +func (this *NidOptCustom) GetId() Uuid { + return this.Id +} + +func (this *NidOptCustom) GetValue() github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNidOptCustomFromFace(that NidOptCustomFace) *NidOptCustom { + this := &NidOptCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type CustomDashFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetValue() *github_com_gogo_protobuf_test_custom_dash_type.Bytes +} + +func (this *CustomDash) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomDash) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomDashFromFace(this) +} + +func (this *CustomDash) GetValue() *github_com_gogo_protobuf_test_custom_dash_type.Bytes { + return this.Value +} + +func NewCustomDashFromFace(that CustomDashFace) *CustomDash { + this := &CustomDash{} + this.Value = that.GetValue() + return this +} + +type NinOptCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() *Uuid + GetValue() *github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NinOptCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptCustomFromFace(this) +} + +func (this *NinOptCustom) GetId() *Uuid { + return this.Id +} + +func (this *NinOptCustom) GetValue() *github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNinOptCustomFromFace(that NinOptCustomFace) *NinOptCustom { + this := &NinOptCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NidRepCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() []Uuid + GetValue() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NidRepCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepCustomFromFace(this) +} + +func (this *NidRepCustom) GetId() []Uuid { + return this.Id +} + +func (this *NidRepCustom) GetValue() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNidRepCustomFromFace(that NidRepCustomFace) *NidRepCustom { + this := &NidRepCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NinRepCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() []Uuid + GetValue() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NinRepCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepCustomFromFace(this) +} + +func (this *NinRepCustom) GetId() []Uuid { + return this.Id +} + +func (this *NinRepCustom) GetValue() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNinRepCustomFromFace(that NinRepCustomFace) *NinRepCustom { + this := &NinRepCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NinOptNativeUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *int32 + GetField4() *int64 + GetField5() *uint32 + GetField6() *uint64 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptNativeUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptNativeUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptNativeUnionFromFace(this) +} + +func (this *NinOptNativeUnion) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptNativeUnion) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptNativeUnion) GetField3() *int32 { + return this.Field3 +} + +func (this *NinOptNativeUnion) GetField4() *int64 { + return this.Field4 +} + +func (this *NinOptNativeUnion) GetField5() *uint32 { + return this.Field5 +} + +func (this *NinOptNativeUnion) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptNativeUnion) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptNativeUnion) GetField14() *string { + return this.Field14 +} + +func (this *NinOptNativeUnion) GetField15() []byte { + return this.Field15 +} + +func NewNinOptNativeUnionFromFace(that NinOptNativeUnionFace) *NinOptNativeUnion { + this := &NinOptNativeUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *NidOptNative + GetField4() *NinOptNative + GetField6() *uint64 + GetField7() *int32 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptStructUnionFromFace(this) +} + +func (this *NinOptStructUnion) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptStructUnion) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptStructUnion) GetField3() *NidOptNative { + return this.Field3 +} + +func (this *NinOptStructUnion) GetField4() *NinOptNative { + return this.Field4 +} + +func (this *NinOptStructUnion) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptStructUnion) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptStructUnion) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptStructUnion) GetField14() *string { + return this.Field14 +} + +func (this *NinOptStructUnion) GetField15() []byte { + return this.Field15 +} + +func NewNinOptStructUnionFromFace(that NinOptStructUnionFace) *NinOptStructUnion { + this := &NinOptStructUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinEmbeddedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() *NinOptNative + GetField210() *bool +} + +func (this *NinEmbeddedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinEmbeddedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinEmbeddedStructUnionFromFace(this) +} + +func (this *NinEmbeddedStructUnion) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NinEmbeddedStructUnion) GetField200() *NinOptNative { + return this.Field200 +} + +func (this *NinEmbeddedStructUnion) GetField210() *bool { + return this.Field210 +} + +func NewNinEmbeddedStructUnionFromFace(that NinEmbeddedStructUnionFace) *NinEmbeddedStructUnion { + this := &NinEmbeddedStructUnion{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NinNestedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *NinOptNativeUnion + GetField2() *NinOptStructUnion + GetField3() *NinEmbeddedStructUnion +} + +func (this *NinNestedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinNestedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinNestedStructUnionFromFace(this) +} + +func (this *NinNestedStructUnion) GetField1() *NinOptNativeUnion { + return this.Field1 +} + +func (this *NinNestedStructUnion) GetField2() *NinOptStructUnion { + return this.Field2 +} + +func (this *NinNestedStructUnion) GetField3() *NinEmbeddedStructUnion { + return this.Field3 +} + +func NewNinNestedStructUnionFromFace(that NinNestedStructUnionFace) *NinNestedStructUnion { + this := &NinNestedStructUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + return this +} + +type TreeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetOr() *OrBranch + GetAnd() *AndBranch + GetLeaf() *Leaf +} + +func (this *Tree) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Tree) TestProto() github_com_gogo_protobuf_proto.Message { + return NewTreeFromFace(this) +} + +func (this *Tree) GetOr() *OrBranch { + return this.Or +} + +func (this *Tree) GetAnd() *AndBranch { + return this.And +} + +func (this *Tree) GetLeaf() *Leaf { + return this.Leaf +} + +func NewTreeFromFace(that TreeFace) *Tree { + this := &Tree{} + this.Or = that.GetOr() + this.And = that.GetAnd() + this.Leaf = that.GetLeaf() + return this +} + +type OrBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() Tree + GetRight() Tree +} + +func (this *OrBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *OrBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewOrBranchFromFace(this) +} + +func (this *OrBranch) GetLeft() Tree { + return this.Left +} + +func (this *OrBranch) GetRight() Tree { + return this.Right +} + +func NewOrBranchFromFace(that OrBranchFace) *OrBranch { + this := &OrBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type AndBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() Tree + GetRight() Tree +} + +func (this *AndBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AndBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAndBranchFromFace(this) +} + +func (this *AndBranch) GetLeft() Tree { + return this.Left +} + +func (this *AndBranch) GetRight() Tree { + return this.Right +} + +func NewAndBranchFromFace(that AndBranchFace) *AndBranch { + this := &AndBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type LeafFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetValue() int64 + GetStrValue() string +} + +func (this *Leaf) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Leaf) TestProto() github_com_gogo_protobuf_proto.Message { + return NewLeafFromFace(this) +} + +func (this *Leaf) GetValue() int64 { + return this.Value +} + +func (this *Leaf) GetStrValue() string { + return this.StrValue +} + +func NewLeafFromFace(that LeafFace) *Leaf { + this := &Leaf{} + this.Value = that.GetValue() + this.StrValue = that.GetStrValue() + return this +} + +type DeepTreeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetDown() *ADeepBranch + GetAnd() *AndDeepBranch + GetLeaf() *DeepLeaf +} + +func (this *DeepTree) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *DeepTree) TestProto() github_com_gogo_protobuf_proto.Message { + return NewDeepTreeFromFace(this) +} + +func (this *DeepTree) GetDown() *ADeepBranch { + return this.Down +} + +func (this *DeepTree) GetAnd() *AndDeepBranch { + return this.And +} + +func (this *DeepTree) GetLeaf() *DeepLeaf { + return this.Leaf +} + +func NewDeepTreeFromFace(that DeepTreeFace) *DeepTree { + this := &DeepTree{} + this.Down = that.GetDown() + this.And = that.GetAnd() + this.Leaf = that.GetLeaf() + return this +} + +type ADeepBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetDown() DeepTree +} + +func (this *ADeepBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *ADeepBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewADeepBranchFromFace(this) +} + +func (this *ADeepBranch) GetDown() DeepTree { + return this.Down +} + +func NewADeepBranchFromFace(that ADeepBranchFace) *ADeepBranch { + this := &ADeepBranch{} + this.Down = that.GetDown() + return this +} + +type AndDeepBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() DeepTree + GetRight() DeepTree +} + +func (this *AndDeepBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AndDeepBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAndDeepBranchFromFace(this) +} + +func (this *AndDeepBranch) GetLeft() DeepTree { + return this.Left +} + +func (this *AndDeepBranch) GetRight() DeepTree { + return this.Right +} + +func NewAndDeepBranchFromFace(that AndDeepBranchFace) *AndDeepBranch { + this := &AndDeepBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type DeepLeafFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetTree() Tree +} + +func (this *DeepLeaf) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *DeepLeaf) TestProto() github_com_gogo_protobuf_proto.Message { + return NewDeepLeafFromFace(this) +} + +func (this *DeepLeaf) GetTree() Tree { + return this.Tree +} + +func NewDeepLeafFromFace(that DeepLeafFace) *DeepLeaf { + this := &DeepLeaf{} + this.Tree = that.GetTree() + return this +} + +type NilFace interface { + Proto() github_com_gogo_protobuf_proto.Message +} + +func (this *Nil) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Nil) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNilFromFace(this) +} + +func NewNilFromFace(that NilFace) *Nil { + this := &Nil{} + return this +} + +type NidOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() TheTestEnum +} + +func (this *NidOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptEnumFromFace(this) +} + +func (this *NidOptEnum) GetField1() TheTestEnum { + return this.Field1 +} + +func NewNidOptEnumFromFace(that NidOptEnumFace) *NidOptEnum { + this := &NidOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type NinOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *TheTestEnum +} + +func (this *NinOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptEnumFromFace(this) +} + +func (this *NinOptEnum) GetField1() *TheTestEnum { + return this.Field1 +} + +func NewNinOptEnumFromFace(that NinOptEnumFace) *NinOptEnum { + this := &NinOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type NidRepEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []TheTestEnum +} + +func (this *NidRepEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepEnumFromFace(this) +} + +func (this *NidRepEnum) GetField1() []TheTestEnum { + return this.Field1 +} + +func NewNidRepEnumFromFace(that NidRepEnumFace) *NidRepEnum { + this := &NidRepEnum{} + this.Field1 = that.GetField1() + return this +} + +type NinRepEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []TheTestEnum +} + +func (this *NinRepEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepEnumFromFace(this) +} + +func (this *NinRepEnum) GetField1() []TheTestEnum { + return this.Field1 +} + +func NewNinRepEnumFromFace(that NinRepEnumFace) *NinRepEnum { + this := &NinRepEnum{} + this.Field1 = that.GetField1() + return this +} + +type AnotherNinOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *AnotherTestEnum +} + +func (this *AnotherNinOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AnotherNinOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAnotherNinOptEnumFromFace(this) +} + +func (this *AnotherNinOptEnum) GetField1() *AnotherTestEnum { + return this.Field1 +} + +func NewAnotherNinOptEnumFromFace(that AnotherNinOptEnumFace) *AnotherNinOptEnum { + this := &AnotherNinOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type TimerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetTime1() int64 + GetTime2() int64 + GetData() []byte +} + +func (this *Timer) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Timer) TestProto() github_com_gogo_protobuf_proto.Message { + return NewTimerFromFace(this) +} + +func (this *Timer) GetTime1() int64 { + return this.Time1 +} + +func (this *Timer) GetTime2() int64 { + return this.Time2 +} + +func (this *Timer) GetData() []byte { + return this.Data +} + +func NewTimerFromFace(that TimerFace) *Timer { + this := &Timer{} + this.Time1 = that.GetTime1() + this.Time2 = that.GetTime2() + this.Data = that.GetData() + return this +} + +type NestedDefinitionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *int64 + GetEnumField() *NestedDefinition_NestedEnum + GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg + GetNM() *NestedDefinition_NestedMessage +} + +func (this *NestedDefinition) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinitionFromFace(this) +} + +func (this *NestedDefinition) GetField1() *int64 { + return this.Field1 +} + +func (this *NestedDefinition) GetEnumField() *NestedDefinition_NestedEnum { + return this.EnumField +} + +func (this *NestedDefinition) GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.NNM +} + +func (this *NestedDefinition) GetNM() *NestedDefinition_NestedMessage { + return this.NM +} + +func NewNestedDefinitionFromFace(that NestedDefinitionFace) *NestedDefinition { + this := &NestedDefinition{} + this.Field1 = that.GetField1() + this.EnumField = that.GetEnumField() + this.NNM = that.GetNNM() + this.NM = that.GetNM() + return this +} + +type NestedDefinition_NestedMessageFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNestedField1() *uint64 + GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg +} + +func (this *NestedDefinition_NestedMessage) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition_NestedMessage) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinition_NestedMessageFromFace(this) +} + +func (this *NestedDefinition_NestedMessage) GetNestedField1() *uint64 { + return this.NestedField1 +} + +func (this *NestedDefinition_NestedMessage) GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.NNM +} + +func NewNestedDefinition_NestedMessageFromFace(that NestedDefinition_NestedMessageFace) *NestedDefinition_NestedMessage { + this := &NestedDefinition_NestedMessage{} + this.NestedField1 = that.GetNestedField1() + this.NNM = that.GetNNM() + return this +} + +type NestedDefinition_NestedMessage_NestedNestedMsgFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNestedNestedField1() *string +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinition_NestedMessage_NestedNestedMsgFromFace(this) +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) GetNestedNestedField1() *string { + return this.NestedNestedField1 +} + +func NewNestedDefinition_NestedMessage_NestedNestedMsgFromFace(that NestedDefinition_NestedMessage_NestedNestedMsgFace) *NestedDefinition_NestedMessage_NestedNestedMsg { + this := &NestedDefinition_NestedMessage_NestedNestedMsg{} + this.NestedNestedField1 = that.GetNestedNestedField1() + return this +} + +type NestedScopeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetA() *NestedDefinition_NestedMessage_NestedNestedMsg + GetB() *NestedDefinition_NestedEnum + GetC() *NestedDefinition_NestedMessage +} + +func (this *NestedScope) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedScope) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedScopeFromFace(this) +} + +func (this *NestedScope) GetA() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.A +} + +func (this *NestedScope) GetB() *NestedDefinition_NestedEnum { + return this.B +} + +func (this *NestedScope) GetC() *NestedDefinition_NestedMessage { + return this.C +} + +func NewNestedScopeFromFace(that NestedScopeFace) *NestedScope { + this := &NestedScope{} + this.A = that.GetA() + this.B = that.GetB() + this.C = that.GetC() + return this +} + +type CustomContainerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetCustomStruct() NidOptCustom +} + +func (this *CustomContainer) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomContainer) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomContainerFromFace(this) +} + +func (this *CustomContainer) GetCustomStruct() NidOptCustom { + return this.CustomStruct +} + +func NewCustomContainerFromFace(that CustomContainerFace) *CustomContainer { + this := &CustomContainer{} + this.CustomStruct = that.GetCustomStruct() + return this +} + +type CustomNameNidOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() float64 + GetFieldB() float32 + GetFieldC() int32 + GetFieldD() int64 + GetFieldE() uint32 + GetFieldF() uint64 + GetFieldG() int32 + GetFieldH() int64 + GetFieldI() uint32 + GetFieldJ() int32 + GetFieldK() uint64 + GetFieldL() int64 + GetFieldM() bool + GetFieldN() string + GetFieldO() []byte +} + +func (this *CustomNameNidOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNidOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNidOptNativeFromFace(this) +} + +func (this *CustomNameNidOptNative) GetFieldA() float64 { + return this.FieldA +} + +func (this *CustomNameNidOptNative) GetFieldB() float32 { + return this.FieldB +} + +func (this *CustomNameNidOptNative) GetFieldC() int32 { + return this.FieldC +} + +func (this *CustomNameNidOptNative) GetFieldD() int64 { + return this.FieldD +} + +func (this *CustomNameNidOptNative) GetFieldE() uint32 { + return this.FieldE +} + +func (this *CustomNameNidOptNative) GetFieldF() uint64 { + return this.FieldF +} + +func (this *CustomNameNidOptNative) GetFieldG() int32 { + return this.FieldG +} + +func (this *CustomNameNidOptNative) GetFieldH() int64 { + return this.FieldH +} + +func (this *CustomNameNidOptNative) GetFieldI() uint32 { + return this.FieldI +} + +func (this *CustomNameNidOptNative) GetFieldJ() int32 { + return this.FieldJ +} + +func (this *CustomNameNidOptNative) GetFieldK() uint64 { + return this.FieldK +} + +func (this *CustomNameNidOptNative) GetFieldL() int64 { + return this.FieldL +} + +func (this *CustomNameNidOptNative) GetFieldM() bool { + return this.FieldM +} + +func (this *CustomNameNidOptNative) GetFieldN() string { + return this.FieldN +} + +func (this *CustomNameNidOptNative) GetFieldO() []byte { + return this.FieldO +} + +func NewCustomNameNidOptNativeFromFace(that CustomNameNidOptNativeFace) *CustomNameNidOptNative { + this := &CustomNameNidOptNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FieldL = that.GetFieldL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *float64 + GetFieldB() *float32 + GetFieldC() *int32 + GetFieldD() *int64 + GetFieldE() *uint32 + GetFieldF() *uint64 + GetFieldG() *int32 + GetFieldH() *int64 + GetFieldI() *uint32 + GetFieldJ() *int32 + GetFieldK() *uint64 + GetFielL() *int64 + GetFieldM() *bool + GetFieldN() *string + GetFieldO() []byte +} + +func (this *CustomNameNinOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinOptNativeFromFace(this) +} + +func (this *CustomNameNinOptNative) GetFieldA() *float64 { + return this.FieldA +} + +func (this *CustomNameNinOptNative) GetFieldB() *float32 { + return this.FieldB +} + +func (this *CustomNameNinOptNative) GetFieldC() *int32 { + return this.FieldC +} + +func (this *CustomNameNinOptNative) GetFieldD() *int64 { + return this.FieldD +} + +func (this *CustomNameNinOptNative) GetFieldE() *uint32 { + return this.FieldE +} + +func (this *CustomNameNinOptNative) GetFieldF() *uint64 { + return this.FieldF +} + +func (this *CustomNameNinOptNative) GetFieldG() *int32 { + return this.FieldG +} + +func (this *CustomNameNinOptNative) GetFieldH() *int64 { + return this.FieldH +} + +func (this *CustomNameNinOptNative) GetFieldI() *uint32 { + return this.FieldI +} + +func (this *CustomNameNinOptNative) GetFieldJ() *int32 { + return this.FieldJ +} + +func (this *CustomNameNinOptNative) GetFieldK() *uint64 { + return this.FieldK +} + +func (this *CustomNameNinOptNative) GetFielL() *int64 { + return this.FielL +} + +func (this *CustomNameNinOptNative) GetFieldM() *bool { + return this.FieldM +} + +func (this *CustomNameNinOptNative) GetFieldN() *string { + return this.FieldN +} + +func (this *CustomNameNinOptNative) GetFieldO() []byte { + return this.FieldO +} + +func NewCustomNameNinOptNativeFromFace(that CustomNameNinOptNativeFace) *CustomNameNinOptNative { + this := &CustomNameNinOptNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FielL = that.GetFielL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() []float64 + GetFieldB() []float32 + GetFieldC() []int32 + GetFieldD() []int64 + GetFieldE() []uint32 + GetFieldF() []uint64 + GetFieldG() []int32 + GetFieldH() []int64 + GetFieldI() []uint32 + GetFieldJ() []int32 + GetFieldK() []uint64 + GetFieldL() []int64 + GetFieldM() []bool + GetFieldN() []string + GetFieldO() [][]byte +} + +func (this *CustomNameNinRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinRepNativeFromFace(this) +} + +func (this *CustomNameNinRepNative) GetFieldA() []float64 { + return this.FieldA +} + +func (this *CustomNameNinRepNative) GetFieldB() []float32 { + return this.FieldB +} + +func (this *CustomNameNinRepNative) GetFieldC() []int32 { + return this.FieldC +} + +func (this *CustomNameNinRepNative) GetFieldD() []int64 { + return this.FieldD +} + +func (this *CustomNameNinRepNative) GetFieldE() []uint32 { + return this.FieldE +} + +func (this *CustomNameNinRepNative) GetFieldF() []uint64 { + return this.FieldF +} + +func (this *CustomNameNinRepNative) GetFieldG() []int32 { + return this.FieldG +} + +func (this *CustomNameNinRepNative) GetFieldH() []int64 { + return this.FieldH +} + +func (this *CustomNameNinRepNative) GetFieldI() []uint32 { + return this.FieldI +} + +func (this *CustomNameNinRepNative) GetFieldJ() []int32 { + return this.FieldJ +} + +func (this *CustomNameNinRepNative) GetFieldK() []uint64 { + return this.FieldK +} + +func (this *CustomNameNinRepNative) GetFieldL() []int64 { + return this.FieldL +} + +func (this *CustomNameNinRepNative) GetFieldM() []bool { + return this.FieldM +} + +func (this *CustomNameNinRepNative) GetFieldN() []string { + return this.FieldN +} + +func (this *CustomNameNinRepNative) GetFieldO() [][]byte { + return this.FieldO +} + +func NewCustomNameNinRepNativeFromFace(that CustomNameNinRepNativeFace) *CustomNameNinRepNative { + this := &CustomNameNinRepNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FieldL = that.GetFieldL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *float64 + GetFieldB() *float32 + GetFieldC() *NidOptNative + GetFieldD() []*NinOptNative + GetFieldE() *uint64 + GetFieldF() *int32 + GetFieldG() *NidOptNative + GetFieldH() *bool + GetFieldI() *string + GetFieldJ() []byte +} + +func (this *CustomNameNinStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinStructFromFace(this) +} + +func (this *CustomNameNinStruct) GetFieldA() *float64 { + return this.FieldA +} + +func (this *CustomNameNinStruct) GetFieldB() *float32 { + return this.FieldB +} + +func (this *CustomNameNinStruct) GetFieldC() *NidOptNative { + return this.FieldC +} + +func (this *CustomNameNinStruct) GetFieldD() []*NinOptNative { + return this.FieldD +} + +func (this *CustomNameNinStruct) GetFieldE() *uint64 { + return this.FieldE +} + +func (this *CustomNameNinStruct) GetFieldF() *int32 { + return this.FieldF +} + +func (this *CustomNameNinStruct) GetFieldG() *NidOptNative { + return this.FieldG +} + +func (this *CustomNameNinStruct) GetFieldH() *bool { + return this.FieldH +} + +func (this *CustomNameNinStruct) GetFieldI() *string { + return this.FieldI +} + +func (this *CustomNameNinStruct) GetFieldJ() []byte { + return this.FieldJ +} + +func NewCustomNameNinStructFromFace(that CustomNameNinStructFace) *CustomNameNinStruct { + this := &CustomNameNinStruct{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + return this +} + +type CustomNameCustomTypeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *Uuid + GetFieldB() *github_com_gogo_protobuf_test_custom.Uint128 + GetFieldC() []Uuid + GetFieldD() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *CustomNameCustomType) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameCustomType) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameCustomTypeFromFace(this) +} + +func (this *CustomNameCustomType) GetFieldA() *Uuid { + return this.FieldA +} + +func (this *CustomNameCustomType) GetFieldB() *github_com_gogo_protobuf_test_custom.Uint128 { + return this.FieldB +} + +func (this *CustomNameCustomType) GetFieldC() []Uuid { + return this.FieldC +} + +func (this *CustomNameCustomType) GetFieldD() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.FieldD +} + +func NewCustomNameCustomTypeFromFace(that CustomNameCustomTypeFace) *CustomNameCustomType { + this := &CustomNameCustomType{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + return this +} + +type CustomNameNinEmbeddedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetFieldA() *NinOptNative + GetFieldB() *bool +} + +func (this *CustomNameNinEmbeddedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinEmbeddedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinEmbeddedStructUnionFromFace(this) +} + +func (this *CustomNameNinEmbeddedStructUnion) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *CustomNameNinEmbeddedStructUnion) GetFieldA() *NinOptNative { + return this.FieldA +} + +func (this *CustomNameNinEmbeddedStructUnion) GetFieldB() *bool { + return this.FieldB +} + +func NewCustomNameNinEmbeddedStructUnionFromFace(that CustomNameNinEmbeddedStructUnionFace) *CustomNameNinEmbeddedStructUnion { + this := &CustomNameNinEmbeddedStructUnion{} + this.NidOptNative = that.GetNidOptNative() + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + return this +} + +type CustomNameEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *TheTestEnum + GetFieldB() []TheTestEnum +} + +func (this *CustomNameEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameEnumFromFace(this) +} + +func (this *CustomNameEnum) GetFieldA() *TheTestEnum { + return this.FieldA +} + +func (this *CustomNameEnum) GetFieldB() []TheTestEnum { + return this.FieldB +} + +func NewCustomNameEnumFromFace(that CustomNameEnumFace) *CustomNameEnum { + this := &CustomNameEnum{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + return this +} + +type UnrecognizedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *string +} + +func (this *Unrecognized) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Unrecognized) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedFromFace(this) +} + +func (this *Unrecognized) GetField1() *string { + return this.Field1 +} + +func NewUnrecognizedFromFace(that UnrecognizedFace) *Unrecognized { + this := &Unrecognized{} + this.Field1 = that.GetField1() + return this +} + +type UnrecognizedWithInnerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetEmbedded() []*UnrecognizedWithInner_Inner + GetField2() *string +} + +func (this *UnrecognizedWithInner) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithInner) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithInnerFromFace(this) +} + +func (this *UnrecognizedWithInner) GetEmbedded() []*UnrecognizedWithInner_Inner { + return this.Embedded +} + +func (this *UnrecognizedWithInner) GetField2() *string { + return this.Field2 +} + +func NewUnrecognizedWithInnerFromFace(that UnrecognizedWithInnerFace) *UnrecognizedWithInner { + this := &UnrecognizedWithInner{} + this.Embedded = that.GetEmbedded() + this.Field2 = that.GetField2() + return this +} + +type UnrecognizedWithInner_InnerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *uint32 +} + +func (this *UnrecognizedWithInner_Inner) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithInner_Inner) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithInner_InnerFromFace(this) +} + +func (this *UnrecognizedWithInner_Inner) GetField1() *uint32 { + return this.Field1 +} + +func NewUnrecognizedWithInner_InnerFromFace(that UnrecognizedWithInner_InnerFace) *UnrecognizedWithInner_Inner { + this := &UnrecognizedWithInner_Inner{} + this.Field1 = that.GetField1() + return this +} + +type UnrecognizedWithEmbedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetUnrecognizedWithEmbed_Embedded() UnrecognizedWithEmbed_Embedded + GetField2() *string +} + +func (this *UnrecognizedWithEmbed) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithEmbed) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithEmbedFromFace(this) +} + +func (this *UnrecognizedWithEmbed) GetUnrecognizedWithEmbed_Embedded() UnrecognizedWithEmbed_Embedded { + return this.UnrecognizedWithEmbed_Embedded +} + +func (this *UnrecognizedWithEmbed) GetField2() *string { + return this.Field2 +} + +func NewUnrecognizedWithEmbedFromFace(that UnrecognizedWithEmbedFace) *UnrecognizedWithEmbed { + this := &UnrecognizedWithEmbed{} + this.UnrecognizedWithEmbed_Embedded = that.GetUnrecognizedWithEmbed_Embedded() + this.Field2 = that.GetField2() + return this +} + +type UnrecognizedWithEmbed_EmbeddedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *uint32 +} + +func (this *UnrecognizedWithEmbed_Embedded) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithEmbed_Embedded) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithEmbed_EmbeddedFromFace(this) +} + +func (this *UnrecognizedWithEmbed_Embedded) GetField1() *uint32 { + return this.Field1 +} + +func NewUnrecognizedWithEmbed_EmbeddedFromFace(that UnrecognizedWithEmbed_EmbeddedFace) *UnrecognizedWithEmbed_Embedded { + this := &UnrecognizedWithEmbed_Embedded{} + this.Field1 = that.GetField1() + return this +} + +func (this *NidOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NidOptNative{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinOptNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+valueToGoStringThetest(this.Field8, "int64")+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+valueToGoStringThetest(this.Field9, "uint32")+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+valueToGoStringThetest(this.Field10, "int32")+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+valueToGoStringThetest(this.Field11, "uint64")+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+valueToGoStringThetest(this.Field12, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NidRepNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinRepNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepPackedNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 17) + s = append(s, "&test.NidRepPackedNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepPackedNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 17) + s = append(s, "&test.NinRepPackedNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NidOptStruct{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + s = append(s, "Field3: "+strings.Replace(this.Field3.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field4: "+strings.Replace(this.Field4.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + s = append(s, "Field8: "+strings.Replace(this.Field8.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NinOptStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NidRepStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+strings.Replace(fmt.Sprintf("%#v", this.Field3), `&`, ``, 1)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+strings.Replace(fmt.Sprintf("%#v", this.Field4), `&`, ``, 1)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+strings.Replace(fmt.Sprintf("%#v", this.Field8), `&`, ``, 1)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NinRepStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidEmbeddedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NidEmbeddedStruct{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + s = append(s, "Field200: "+strings.Replace(this.Field200.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field210: "+fmt.Sprintf("%#v", this.Field210)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinEmbeddedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinEmbeddedStruct{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.Field200 != nil { + s = append(s, "Field200: "+fmt.Sprintf("%#v", this.Field200)+",\n") + } + if this.Field210 != nil { + s = append(s, "Field210: "+valueToGoStringThetest(this.Field210, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidNestedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidNestedStruct{") + s = append(s, "Field1: "+strings.Replace(this.Field1.GoString(), `&`, ``, 1)+",\n") + if this.Field2 != nil { + s = append(s, "Field2: "+strings.Replace(fmt.Sprintf("%#v", this.Field2), `&`, ``, 1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinNestedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinNestedStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidOptCustom{") + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomDash) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.CustomDash{") + if this.Value != nil { + s = append(s, "Value: "+valueToGoStringThetest(this.Value, "github_com_gogo_protobuf_test_custom_dash_type.Bytes")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinOptCustom{") + if this.Id != nil { + s = append(s, "Id: "+valueToGoStringThetest(this.Id, "Uuid")+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+valueToGoStringThetest(this.Value, "github_com_gogo_protobuf_test_custom.Uint128")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidRepCustom{") + if this.Id != nil { + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinRepCustom{") + if this.Id != nil { + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNativeUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 13) + s = append(s, "&test.NinOptNativeUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 13) + s = append(s, "&test.NinOptStructUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinEmbeddedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinEmbeddedStructUnion{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.Field200 != nil { + s = append(s, "Field200: "+fmt.Sprintf("%#v", this.Field200)+",\n") + } + if this.Field210 != nil { + s = append(s, "Field210: "+valueToGoStringThetest(this.Field210, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinNestedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinNestedStructUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Tree) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.Tree{") + if this.Or != nil { + s = append(s, "Or: "+fmt.Sprintf("%#v", this.Or)+",\n") + } + if this.And != nil { + s = append(s, "And: "+fmt.Sprintf("%#v", this.And)+",\n") + } + if this.Leaf != nil { + s = append(s, "Leaf: "+fmt.Sprintf("%#v", this.Leaf)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OrBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.OrBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AndBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.AndBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Leaf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.Leaf{") + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + s = append(s, "StrValue: "+fmt.Sprintf("%#v", this.StrValue)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DeepTree) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.DeepTree{") + if this.Down != nil { + s = append(s, "Down: "+fmt.Sprintf("%#v", this.Down)+",\n") + } + if this.And != nil { + s = append(s, "And: "+fmt.Sprintf("%#v", this.And)+",\n") + } + if this.Leaf != nil { + s = append(s, "Leaf: "+fmt.Sprintf("%#v", this.Leaf)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *ADeepBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.ADeepBranch{") + s = append(s, "Down: "+strings.Replace(this.Down.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AndDeepBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.AndDeepBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DeepLeaf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.DeepLeaf{") + s = append(s, "Tree: "+strings.Replace(this.Tree.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Nil) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 4) + s = append(s, "&test.Nil{") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NidOptEnum{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinOptEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.TheTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NidRepEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinRepEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptEnumDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinOptEnumDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.TheTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AnotherNinOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.AnotherNinOptEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.AnotherTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AnotherNinOptEnumDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.AnotherNinOptEnumDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.AnotherTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Timer) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.Timer{") + s = append(s, "Time1: "+fmt.Sprintf("%#v", this.Time1)+",\n") + s = append(s, "Time2: "+fmt.Sprintf("%#v", this.Time2)+",\n") + s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MyExtendable) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.MyExtendable{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringThetest(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OtherExtenable) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.OtherExtenable{") + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "int64")+",\n") + } + if this.M != nil { + s = append(s, "M: "+fmt.Sprintf("%#v", this.M)+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringThetest(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&test.NestedDefinition{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.EnumField != nil { + s = append(s, "EnumField: "+valueToGoStringThetest(this.EnumField, "test.NestedDefinition_NestedEnum")+",\n") + } + if this.NNM != nil { + s = append(s, "NNM: "+fmt.Sprintf("%#v", this.NNM)+",\n") + } + if this.NM != nil { + s = append(s, "NM: "+fmt.Sprintf("%#v", this.NM)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition_NestedMessage) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NestedDefinition_NestedMessage{") + if this.NestedField1 != nil { + s = append(s, "NestedField1: "+valueToGoStringThetest(this.NestedField1, "uint64")+",\n") + } + if this.NNM != nil { + s = append(s, "NNM: "+fmt.Sprintf("%#v", this.NNM)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NestedDefinition_NestedMessage_NestedNestedMsg{") + if this.NestedNestedField1 != nil { + s = append(s, "NestedNestedField1: "+valueToGoStringThetest(this.NestedNestedField1, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedScope) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NestedScope{") + if this.A != nil { + s = append(s, "A: "+fmt.Sprintf("%#v", this.A)+",\n") + } + if this.B != nil { + s = append(s, "B: "+valueToGoStringThetest(this.B, "test.NestedDefinition_NestedEnum")+",\n") + } + if this.C != nil { + s = append(s, "C: "+fmt.Sprintf("%#v", this.C)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNativeDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinOptNativeDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+valueToGoStringThetest(this.Field8, "int64")+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+valueToGoStringThetest(this.Field9, "uint32")+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+valueToGoStringThetest(this.Field10, "int32")+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+valueToGoStringThetest(this.Field11, "uint64")+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+valueToGoStringThetest(this.Field12, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomContainer) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.CustomContainer{") + s = append(s, "CustomStruct: "+strings.Replace(this.CustomStruct.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNidOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNidOptNative{") + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + s = append(s, "FieldE: "+fmt.Sprintf("%#v", this.FieldE)+",\n") + s = append(s, "FieldF: "+fmt.Sprintf("%#v", this.FieldF)+",\n") + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + s = append(s, "FieldH: "+fmt.Sprintf("%#v", this.FieldH)+",\n") + s = append(s, "FieldI: "+fmt.Sprintf("%#v", this.FieldI)+",\n") + s = append(s, "FieldJ: "+fmt.Sprintf("%#v", this.FieldJ)+",\n") + s = append(s, "FieldK: "+fmt.Sprintf("%#v", this.FieldK)+",\n") + s = append(s, "FieldL: "+fmt.Sprintf("%#v", this.FieldL)+",\n") + s = append(s, "FieldM: "+fmt.Sprintf("%#v", this.FieldM)+",\n") + s = append(s, "FieldN: "+fmt.Sprintf("%#v", this.FieldN)+",\n") + s = append(s, "FieldO: "+fmt.Sprintf("%#v", this.FieldO)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNinOptNative{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "float64")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "float32")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+valueToGoStringThetest(this.FieldC, "int32")+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+valueToGoStringThetest(this.FieldD, "int64")+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+valueToGoStringThetest(this.FieldE, "uint32")+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+valueToGoStringThetest(this.FieldF, "uint64")+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+valueToGoStringThetest(this.FieldG, "int32")+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+valueToGoStringThetest(this.FieldH, "int64")+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+valueToGoStringThetest(this.FieldI, "uint32")+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+valueToGoStringThetest(this.FieldJ, "int32")+",\n") + } + if this.FieldK != nil { + s = append(s, "FieldK: "+valueToGoStringThetest(this.FieldK, "uint64")+",\n") + } + if this.FielL != nil { + s = append(s, "FielL: "+valueToGoStringThetest(this.FielL, "int64")+",\n") + } + if this.FieldM != nil { + s = append(s, "FieldM: "+valueToGoStringThetest(this.FieldM, "bool")+",\n") + } + if this.FieldN != nil { + s = append(s, "FieldN: "+valueToGoStringThetest(this.FieldN, "string")+",\n") + } + if this.FieldO != nil { + s = append(s, "FieldO: "+valueToGoStringThetest(this.FieldO, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNinRepNative{") + if this.FieldA != nil { + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+fmt.Sprintf("%#v", this.FieldE)+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+fmt.Sprintf("%#v", this.FieldF)+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+fmt.Sprintf("%#v", this.FieldH)+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+fmt.Sprintf("%#v", this.FieldI)+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+fmt.Sprintf("%#v", this.FieldJ)+",\n") + } + if this.FieldK != nil { + s = append(s, "FieldK: "+fmt.Sprintf("%#v", this.FieldK)+",\n") + } + if this.FieldL != nil { + s = append(s, "FieldL: "+fmt.Sprintf("%#v", this.FieldL)+",\n") + } + if this.FieldM != nil { + s = append(s, "FieldM: "+fmt.Sprintf("%#v", this.FieldM)+",\n") + } + if this.FieldN != nil { + s = append(s, "FieldN: "+fmt.Sprintf("%#v", this.FieldN)+",\n") + } + if this.FieldO != nil { + s = append(s, "FieldO: "+fmt.Sprintf("%#v", this.FieldO)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.CustomNameNinStruct{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "float64")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "float32")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+valueToGoStringThetest(this.FieldE, "uint64")+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+valueToGoStringThetest(this.FieldF, "int32")+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+valueToGoStringThetest(this.FieldH, "bool")+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+valueToGoStringThetest(this.FieldI, "string")+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+valueToGoStringThetest(this.FieldJ, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameCustomType) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&test.CustomNameCustomType{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "Uuid")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "github_com_gogo_protobuf_test_custom.Uint128")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinEmbeddedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.CustomNameNinEmbeddedStructUnion{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.FieldA != nil { + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.CustomNameEnum{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "test.TheTestEnum")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NoExtensionsMap) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NoExtensionsMap{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+fmt.Sprintf("%#v", this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Unrecognized) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.Unrecognized{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "string")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithInner) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.UnrecognizedWithInner{") + if this.Embedded != nil { + s = append(s, "Embedded: "+fmt.Sprintf("%#v", this.Embedded)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithInner_Inner) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.UnrecognizedWithInner_Inner{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "uint32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithEmbed) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.UnrecognizedWithEmbed{") + s = append(s, "UnrecognizedWithEmbed_Embedded: "+strings.Replace(this.UnrecognizedWithEmbed_Embedded.GoString(), `&`, ``, 1)+",\n") + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithEmbed_Embedded) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.UnrecognizedWithEmbed_Embedded{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "uint32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringThetest(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringThetest(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedNidOptNative(r randyThetest, easy bool) *NidOptNative { + this := &NidOptNative{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + this.Field5 = uint32(r.Uint32()) + this.Field6 = uint64(uint64(r.Uint32())) + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + this.Field9 = uint32(r.Uint32()) + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + this.Field11 = uint64(uint64(r.Uint32())) + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + this.Field13 = bool(bool(r.Intn(2) == 0)) + this.Field14 = randStringThetest(r) + v1 := r.Intn(100) + this.Field15 = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinOptNative(r randyThetest, easy bool) *NinOptNative { + this := &NinOptNative{} + if r.Intn(10) != 0 { + v2 := float64(r.Float64()) + if r.Intn(2) == 0 { + v2 *= -1 + } + this.Field1 = &v2 + } + if r.Intn(10) != 0 { + v3 := float32(r.Float32()) + if r.Intn(2) == 0 { + v3 *= -1 + } + this.Field2 = &v3 + } + if r.Intn(10) != 0 { + v4 := int32(r.Int31()) + if r.Intn(2) == 0 { + v4 *= -1 + } + this.Field3 = &v4 + } + if r.Intn(10) != 0 { + v5 := int64(r.Int63()) + if r.Intn(2) == 0 { + v5 *= -1 + } + this.Field4 = &v5 + } + if r.Intn(10) != 0 { + v6 := uint32(r.Uint32()) + this.Field5 = &v6 + } + if r.Intn(10) != 0 { + v7 := uint64(uint64(r.Uint32())) + this.Field6 = &v7 + } + if r.Intn(10) != 0 { + v8 := int32(r.Int31()) + if r.Intn(2) == 0 { + v8 *= -1 + } + this.Field7 = &v8 + } + if r.Intn(10) != 0 { + v9 := int64(r.Int63()) + if r.Intn(2) == 0 { + v9 *= -1 + } + this.Field8 = &v9 + } + if r.Intn(10) != 0 { + v10 := uint32(r.Uint32()) + this.Field9 = &v10 + } + if r.Intn(10) != 0 { + v11 := int32(r.Int31()) + if r.Intn(2) == 0 { + v11 *= -1 + } + this.Field10 = &v11 + } + if r.Intn(10) != 0 { + v12 := uint64(uint64(r.Uint32())) + this.Field11 = &v12 + } + if r.Intn(10) != 0 { + v13 := int64(r.Int63()) + if r.Intn(2) == 0 { + v13 *= -1 + } + this.Field12 = &v13 + } + if r.Intn(10) != 0 { + v14 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v14 + } + if r.Intn(10) != 0 { + v15 := randStringThetest(r) + this.Field14 = &v15 + } + if r.Intn(10) != 0 { + v16 := r.Intn(100) + this.Field15 = make([]byte, v16) + for i := 0; i < v16; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepNative(r randyThetest, easy bool) *NidRepNative { + this := &NidRepNative{} + if r.Intn(10) != 0 { + v17 := r.Intn(100) + this.Field1 = make([]float64, v17) + for i := 0; i < v17; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v18 := r.Intn(100) + this.Field2 = make([]float32, v18) + for i := 0; i < v18; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v19 := r.Intn(100) + this.Field3 = make([]int32, v19) + for i := 0; i < v19; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v20 := r.Intn(100) + this.Field4 = make([]int64, v20) + for i := 0; i < v20; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v21 := r.Intn(100) + this.Field5 = make([]uint32, v21) + for i := 0; i < v21; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v22 := r.Intn(100) + this.Field6 = make([]uint64, v22) + for i := 0; i < v22; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v23 := r.Intn(100) + this.Field7 = make([]int32, v23) + for i := 0; i < v23; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v24 := r.Intn(100) + this.Field8 = make([]int64, v24) + for i := 0; i < v24; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v25 := r.Intn(100) + this.Field9 = make([]uint32, v25) + for i := 0; i < v25; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v26 := r.Intn(100) + this.Field10 = make([]int32, v26) + for i := 0; i < v26; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v27 := r.Intn(100) + this.Field11 = make([]uint64, v27) + for i := 0; i < v27; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v28 := r.Intn(100) + this.Field12 = make([]int64, v28) + for i := 0; i < v28; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(100) + this.Field13 = make([]bool, v29) + for i := 0; i < v29; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v30 := r.Intn(10) + this.Field14 = make([]string, v30) + for i := 0; i < v30; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v31 := r.Intn(100) + this.Field15 = make([][]byte, v31) + for i := 0; i < v31; i++ { + v32 := r.Intn(100) + this.Field15[i] = make([]byte, v32) + for j := 0; j < v32; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinRepNative(r randyThetest, easy bool) *NinRepNative { + this := &NinRepNative{} + if r.Intn(10) != 0 { + v33 := r.Intn(100) + this.Field1 = make([]float64, v33) + for i := 0; i < v33; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v34 := r.Intn(100) + this.Field2 = make([]float32, v34) + for i := 0; i < v34; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v35 := r.Intn(100) + this.Field3 = make([]int32, v35) + for i := 0; i < v35; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v36 := r.Intn(100) + this.Field4 = make([]int64, v36) + for i := 0; i < v36; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v37 := r.Intn(100) + this.Field5 = make([]uint32, v37) + for i := 0; i < v37; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v38 := r.Intn(100) + this.Field6 = make([]uint64, v38) + for i := 0; i < v38; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v39 := r.Intn(100) + this.Field7 = make([]int32, v39) + for i := 0; i < v39; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v40 := r.Intn(100) + this.Field8 = make([]int64, v40) + for i := 0; i < v40; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v41 := r.Intn(100) + this.Field9 = make([]uint32, v41) + for i := 0; i < v41; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v42 := r.Intn(100) + this.Field10 = make([]int32, v42) + for i := 0; i < v42; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v43 := r.Intn(100) + this.Field11 = make([]uint64, v43) + for i := 0; i < v43; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v44 := r.Intn(100) + this.Field12 = make([]int64, v44) + for i := 0; i < v44; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v45 := r.Intn(100) + this.Field13 = make([]bool, v45) + for i := 0; i < v45; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v46 := r.Intn(10) + this.Field14 = make([]string, v46) + for i := 0; i < v46; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v47 := r.Intn(100) + this.Field15 = make([][]byte, v47) + for i := 0; i < v47; i++ { + v48 := r.Intn(100) + this.Field15[i] = make([]byte, v48) + for j := 0; j < v48; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepPackedNative(r randyThetest, easy bool) *NidRepPackedNative { + this := &NidRepPackedNative{} + if r.Intn(10) != 0 { + v49 := r.Intn(100) + this.Field1 = make([]float64, v49) + for i := 0; i < v49; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v50 := r.Intn(100) + this.Field2 = make([]float32, v50) + for i := 0; i < v50; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v51 := r.Intn(100) + this.Field3 = make([]int32, v51) + for i := 0; i < v51; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v52 := r.Intn(100) + this.Field4 = make([]int64, v52) + for i := 0; i < v52; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v53 := r.Intn(100) + this.Field5 = make([]uint32, v53) + for i := 0; i < v53; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v54 := r.Intn(100) + this.Field6 = make([]uint64, v54) + for i := 0; i < v54; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v55 := r.Intn(100) + this.Field7 = make([]int32, v55) + for i := 0; i < v55; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v56 := r.Intn(100) + this.Field8 = make([]int64, v56) + for i := 0; i < v56; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v57 := r.Intn(100) + this.Field9 = make([]uint32, v57) + for i := 0; i < v57; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v58 := r.Intn(100) + this.Field10 = make([]int32, v58) + for i := 0; i < v58; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v59 := r.Intn(100) + this.Field11 = make([]uint64, v59) + for i := 0; i < v59; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v60 := r.Intn(100) + this.Field12 = make([]int64, v60) + for i := 0; i < v60; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v61 := r.Intn(100) + this.Field13 = make([]bool, v61) + for i := 0; i < v61; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 14) + } + return this +} + +func NewPopulatedNinRepPackedNative(r randyThetest, easy bool) *NinRepPackedNative { + this := &NinRepPackedNative{} + if r.Intn(10) != 0 { + v62 := r.Intn(100) + this.Field1 = make([]float64, v62) + for i := 0; i < v62; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v63 := r.Intn(100) + this.Field2 = make([]float32, v63) + for i := 0; i < v63; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v64 := r.Intn(100) + this.Field3 = make([]int32, v64) + for i := 0; i < v64; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v65 := r.Intn(100) + this.Field4 = make([]int64, v65) + for i := 0; i < v65; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v66 := r.Intn(100) + this.Field5 = make([]uint32, v66) + for i := 0; i < v66; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v67 := r.Intn(100) + this.Field6 = make([]uint64, v67) + for i := 0; i < v67; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v68 := r.Intn(100) + this.Field7 = make([]int32, v68) + for i := 0; i < v68; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v69 := r.Intn(100) + this.Field8 = make([]int64, v69) + for i := 0; i < v69; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v70 := r.Intn(100) + this.Field9 = make([]uint32, v70) + for i := 0; i < v70; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v71 := r.Intn(100) + this.Field10 = make([]int32, v71) + for i := 0; i < v71; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v72 := r.Intn(100) + this.Field11 = make([]uint64, v72) + for i := 0; i < v72; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v73 := r.Intn(100) + this.Field12 = make([]int64, v73) + for i := 0; i < v73; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v74 := r.Intn(100) + this.Field13 = make([]bool, v74) + for i := 0; i < v74; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 14) + } + return this +} + +func NewPopulatedNidOptStruct(r randyThetest, easy bool) *NidOptStruct { + this := &NidOptStruct{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + v75 := NewPopulatedNidOptNative(r, easy) + this.Field3 = *v75 + v76 := NewPopulatedNinOptNative(r, easy) + this.Field4 = *v76 + this.Field6 = uint64(uint64(r.Uint32())) + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + v77 := NewPopulatedNidOptNative(r, easy) + this.Field8 = *v77 + this.Field13 = bool(bool(r.Intn(2) == 0)) + this.Field14 = randStringThetest(r) + v78 := r.Intn(100) + this.Field15 = make([]byte, v78) + for i := 0; i < v78; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinOptStruct(r randyThetest, easy bool) *NinOptStruct { + this := &NinOptStruct{} + if r.Intn(10) != 0 { + v79 := float64(r.Float64()) + if r.Intn(2) == 0 { + v79 *= -1 + } + this.Field1 = &v79 + } + if r.Intn(10) != 0 { + v80 := float32(r.Float32()) + if r.Intn(2) == 0 { + v80 *= -1 + } + this.Field2 = &v80 + } + if r.Intn(10) != 0 { + this.Field3 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + this.Field4 = NewPopulatedNinOptNative(r, easy) + } + if r.Intn(10) != 0 { + v81 := uint64(uint64(r.Uint32())) + this.Field6 = &v81 + } + if r.Intn(10) != 0 { + v82 := int32(r.Int31()) + if r.Intn(2) == 0 { + v82 *= -1 + } + this.Field7 = &v82 + } + if r.Intn(10) != 0 { + this.Field8 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v83 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v83 + } + if r.Intn(10) != 0 { + v84 := randStringThetest(r) + this.Field14 = &v84 + } + if r.Intn(10) != 0 { + v85 := r.Intn(100) + this.Field15 = make([]byte, v85) + for i := 0; i < v85; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepStruct(r randyThetest, easy bool) *NidRepStruct { + this := &NidRepStruct{} + if r.Intn(10) != 0 { + v86 := r.Intn(100) + this.Field1 = make([]float64, v86) + for i := 0; i < v86; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v87 := r.Intn(100) + this.Field2 = make([]float32, v87) + for i := 0; i < v87; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v88 := r.Intn(10) + this.Field3 = make([]NidOptNative, v88) + for i := 0; i < v88; i++ { + v89 := NewPopulatedNidOptNative(r, easy) + this.Field3[i] = *v89 + } + } + if r.Intn(10) != 0 { + v90 := r.Intn(10) + this.Field4 = make([]NinOptNative, v90) + for i := 0; i < v90; i++ { + v91 := NewPopulatedNinOptNative(r, easy) + this.Field4[i] = *v91 + } + } + if r.Intn(10) != 0 { + v92 := r.Intn(100) + this.Field6 = make([]uint64, v92) + for i := 0; i < v92; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v93 := r.Intn(100) + this.Field7 = make([]int32, v93) + for i := 0; i < v93; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v94 := r.Intn(10) + this.Field8 = make([]NidOptNative, v94) + for i := 0; i < v94; i++ { + v95 := NewPopulatedNidOptNative(r, easy) + this.Field8[i] = *v95 + } + } + if r.Intn(10) != 0 { + v96 := r.Intn(100) + this.Field13 = make([]bool, v96) + for i := 0; i < v96; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v97 := r.Intn(10) + this.Field14 = make([]string, v97) + for i := 0; i < v97; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v98 := r.Intn(100) + this.Field15 = make([][]byte, v98) + for i := 0; i < v98; i++ { + v99 := r.Intn(100) + this.Field15[i] = make([]byte, v99) + for j := 0; j < v99; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinRepStruct(r randyThetest, easy bool) *NinRepStruct { + this := &NinRepStruct{} + if r.Intn(10) != 0 { + v100 := r.Intn(100) + this.Field1 = make([]float64, v100) + for i := 0; i < v100; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v101 := r.Intn(100) + this.Field2 = make([]float32, v101) + for i := 0; i < v101; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v102 := r.Intn(10) + this.Field3 = make([]*NidOptNative, v102) + for i := 0; i < v102; i++ { + this.Field3[i] = NewPopulatedNidOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v103 := r.Intn(10) + this.Field4 = make([]*NinOptNative, v103) + for i := 0; i < v103; i++ { + this.Field4[i] = NewPopulatedNinOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v104 := r.Intn(100) + this.Field6 = make([]uint64, v104) + for i := 0; i < v104; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v105 := r.Intn(100) + this.Field7 = make([]int32, v105) + for i := 0; i < v105; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v106 := r.Intn(10) + this.Field8 = make([]*NidOptNative, v106) + for i := 0; i < v106; i++ { + this.Field8[i] = NewPopulatedNidOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v107 := r.Intn(100) + this.Field13 = make([]bool, v107) + for i := 0; i < v107; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v108 := r.Intn(10) + this.Field14 = make([]string, v108) + for i := 0; i < v108; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v109 := r.Intn(100) + this.Field15 = make([][]byte, v109) + for i := 0; i < v109; i++ { + v110 := r.Intn(100) + this.Field15[i] = make([]byte, v110) + for j := 0; j < v110; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidEmbeddedStruct(r randyThetest, easy bool) *NidEmbeddedStruct { + this := &NidEmbeddedStruct{} + if r.Intn(10) != 0 { + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + } + v111 := NewPopulatedNidOptNative(r, easy) + this.Field200 = *v111 + this.Field210 = bool(bool(r.Intn(2) == 0)) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 211) + } + return this +} + +func NewPopulatedNinEmbeddedStruct(r randyThetest, easy bool) *NinEmbeddedStruct { + this := &NinEmbeddedStruct{} + if r.Intn(10) != 0 { + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + this.Field200 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v112 := bool(bool(r.Intn(2) == 0)) + this.Field210 = &v112 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 211) + } + return this +} + +func NewPopulatedNidNestedStruct(r randyThetest, easy bool) *NidNestedStruct { + this := &NidNestedStruct{} + v113 := NewPopulatedNidOptStruct(r, easy) + this.Field1 = *v113 + if r.Intn(10) != 0 { + v114 := r.Intn(10) + this.Field2 = make([]NidRepStruct, v114) + for i := 0; i < v114; i++ { + v115 := NewPopulatedNidRepStruct(r, easy) + this.Field2[i] = *v115 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinNestedStruct(r randyThetest, easy bool) *NinNestedStruct { + this := &NinNestedStruct{} + if r.Intn(10) != 0 { + this.Field1 = NewPopulatedNinOptStruct(r, easy) + } + if r.Intn(10) != 0 { + v116 := r.Intn(10) + this.Field2 = make([]*NinRepStruct, v116) + for i := 0; i < v116; i++ { + this.Field2[i] = NewPopulatedNinRepStruct(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNidOptCustom(r randyThetest, easy bool) *NidOptCustom { + this := &NidOptCustom{} + v117 := NewPopulatedUuid(r) + this.Id = *v117 + v118 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value = *v118 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedCustomDash(r randyThetest, easy bool) *CustomDash { + this := &CustomDash{} + if r.Intn(10) != 0 { + this.Value = github_com_gogo_protobuf_test_custom_dash_type.NewPopulatedBytes(r) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptCustom(r randyThetest, easy bool) *NinOptCustom { + this := &NinOptCustom{} + if r.Intn(10) != 0 { + this.Id = NewPopulatedUuid(r) + } + if r.Intn(10) != 0 { + this.Value = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNidRepCustom(r randyThetest, easy bool) *NidRepCustom { + this := &NidRepCustom{} + if r.Intn(10) != 0 { + v119 := r.Intn(10) + this.Id = make([]Uuid, v119) + for i := 0; i < v119; i++ { + v120 := NewPopulatedUuid(r) + this.Id[i] = *v120 + } + } + if r.Intn(10) != 0 { + v121 := r.Intn(10) + this.Value = make([]github_com_gogo_protobuf_test_custom.Uint128, v121) + for i := 0; i < v121; i++ { + v122 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value[i] = *v122 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinRepCustom(r randyThetest, easy bool) *NinRepCustom { + this := &NinRepCustom{} + if r.Intn(10) != 0 { + v123 := r.Intn(10) + this.Id = make([]Uuid, v123) + for i := 0; i < v123; i++ { + v124 := NewPopulatedUuid(r) + this.Id[i] = *v124 + } + } + if r.Intn(10) != 0 { + v125 := r.Intn(10) + this.Value = make([]github_com_gogo_protobuf_test_custom.Uint128, v125) + for i := 0; i < v125; i++ { + v126 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value[i] = *v126 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinOptNativeUnion(r randyThetest, easy bool) *NinOptNativeUnion { + this := &NinOptNativeUnion{} + fieldNum := r.Intn(9) + switch fieldNum { + case 0: + v127 := float64(r.Float64()) + if r.Intn(2) == 0 { + v127 *= -1 + } + this.Field1 = &v127 + case 1: + v128 := float32(r.Float32()) + if r.Intn(2) == 0 { + v128 *= -1 + } + this.Field2 = &v128 + case 2: + v129 := int32(r.Int31()) + if r.Intn(2) == 0 { + v129 *= -1 + } + this.Field3 = &v129 + case 3: + v130 := int64(r.Int63()) + if r.Intn(2) == 0 { + v130 *= -1 + } + this.Field4 = &v130 + case 4: + v131 := uint32(r.Uint32()) + this.Field5 = &v131 + case 5: + v132 := uint64(uint64(r.Uint32())) + this.Field6 = &v132 + case 6: + v133 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v133 + case 7: + v134 := randStringThetest(r) + this.Field14 = &v134 + case 8: + v135 := r.Intn(100) + this.Field15 = make([]byte, v135) + for i := 0; i < v135; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + return this +} + +func NewPopulatedNinOptStructUnion(r randyThetest, easy bool) *NinOptStructUnion { + this := &NinOptStructUnion{} + fieldNum := r.Intn(9) + switch fieldNum { + case 0: + v136 := float64(r.Float64()) + if r.Intn(2) == 0 { + v136 *= -1 + } + this.Field1 = &v136 + case 1: + v137 := float32(r.Float32()) + if r.Intn(2) == 0 { + v137 *= -1 + } + this.Field2 = &v137 + case 2: + this.Field3 = NewPopulatedNidOptNative(r, easy) + case 3: + this.Field4 = NewPopulatedNinOptNative(r, easy) + case 4: + v138 := uint64(uint64(r.Uint32())) + this.Field6 = &v138 + case 5: + v139 := int32(r.Int31()) + if r.Intn(2) == 0 { + v139 *= -1 + } + this.Field7 = &v139 + case 6: + v140 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v140 + case 7: + v141 := randStringThetest(r) + this.Field14 = &v141 + case 8: + v142 := r.Intn(100) + this.Field15 = make([]byte, v142) + for i := 0; i < v142; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + return this +} + +func NewPopulatedNinEmbeddedStructUnion(r randyThetest, easy bool) *NinEmbeddedStructUnion { + this := &NinEmbeddedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + case 1: + this.Field200 = NewPopulatedNinOptNative(r, easy) + case 2: + v143 := bool(bool(r.Intn(2) == 0)) + this.Field210 = &v143 + } + return this +} + +func NewPopulatedNinNestedStructUnion(r randyThetest, easy bool) *NinNestedStructUnion { + this := &NinNestedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.Field1 = NewPopulatedNinOptNativeUnion(r, easy) + case 1: + this.Field2 = NewPopulatedNinOptStructUnion(r, easy) + case 2: + this.Field3 = NewPopulatedNinEmbeddedStructUnion(r, easy) + } + return this +} + +func NewPopulatedTree(r randyThetest, easy bool) *Tree { + this := &Tree{} + fieldNum := r.Intn(102) + switch fieldNum { + case 0: + this.Or = NewPopulatedOrBranch(r, easy) + case 1: + this.And = NewPopulatedAndBranch(r, easy) + case 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101: + this.Leaf = NewPopulatedLeaf(r, easy) + } + return this +} + +func NewPopulatedOrBranch(r randyThetest, easy bool) *OrBranch { + this := &OrBranch{} + v144 := NewPopulatedTree(r, easy) + this.Left = *v144 + v145 := NewPopulatedTree(r, easy) + this.Right = *v145 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedAndBranch(r randyThetest, easy bool) *AndBranch { + this := &AndBranch{} + v146 := NewPopulatedTree(r, easy) + this.Left = *v146 + v147 := NewPopulatedTree(r, easy) + this.Right = *v147 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedLeaf(r randyThetest, easy bool) *Leaf { + this := &Leaf{} + this.Value = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Value *= -1 + } + this.StrValue = randStringThetest(r) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedDeepTree(r randyThetest, easy bool) *DeepTree { + this := &DeepTree{} + fieldNum := r.Intn(102) + switch fieldNum { + case 0: + this.Down = NewPopulatedADeepBranch(r, easy) + case 1: + this.And = NewPopulatedAndDeepBranch(r, easy) + case 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101: + this.Leaf = NewPopulatedDeepLeaf(r, easy) + } + return this +} + +func NewPopulatedADeepBranch(r randyThetest, easy bool) *ADeepBranch { + this := &ADeepBranch{} + v148 := NewPopulatedDeepTree(r, easy) + this.Down = *v148 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedAndDeepBranch(r randyThetest, easy bool) *AndDeepBranch { + this := &AndDeepBranch{} + v149 := NewPopulatedDeepTree(r, easy) + this.Left = *v149 + v150 := NewPopulatedDeepTree(r, easy) + this.Right = *v150 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedDeepLeaf(r randyThetest, easy bool) *DeepLeaf { + this := &DeepLeaf{} + v151 := NewPopulatedTree(r, easy) + this.Tree = *v151 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNil(r randyThetest, easy bool) *Nil { + this := &Nil{} + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 1) + } + return this +} + +func NewPopulatedNidOptEnum(r randyThetest, easy bool) *NidOptEnum { + this := &NidOptEnum{} + this.Field1 = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptEnum(r randyThetest, easy bool) *NinOptEnum { + this := &NinOptEnum{} + if r.Intn(10) != 0 { + v152 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.Field1 = &v152 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNidRepEnum(r randyThetest, easy bool) *NidRepEnum { + this := &NidRepEnum{} + if r.Intn(10) != 0 { + v153 := r.Intn(10) + this.Field1 = make([]TheTestEnum, v153) + for i := 0; i < v153; i++ { + this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinRepEnum(r randyThetest, easy bool) *NinRepEnum { + this := &NinRepEnum{} + if r.Intn(10) != 0 { + v154 := r.Intn(10) + this.Field1 = make([]TheTestEnum, v154) + for i := 0; i < v154; i++ { + this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptEnumDefault(r randyThetest, easy bool) *NinOptEnumDefault { + this := &NinOptEnumDefault{} + if r.Intn(10) != 0 { + v155 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.Field1 = &v155 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedAnotherNinOptEnum(r randyThetest, easy bool) *AnotherNinOptEnum { + this := &AnotherNinOptEnum{} + if r.Intn(10) != 0 { + v156 := AnotherTestEnum([]int32{10, 11}[r.Intn(2)]) + this.Field1 = &v156 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedAnotherNinOptEnumDefault(r randyThetest, easy bool) *AnotherNinOptEnumDefault { + this := &AnotherNinOptEnumDefault{} + if r.Intn(10) != 0 { + v157 := AnotherTestEnum([]int32{10, 11}[r.Intn(2)]) + this.Field1 = &v157 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedTimer(r randyThetest, easy bool) *Timer { + this := &Timer{} + this.Time1 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Time1 *= -1 + } + this.Time2 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Time2 *= -1 + } + v158 := r.Intn(100) + this.Data = make([]byte, v158) + for i := 0; i < v158; i++ { + this.Data[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 4) + } + return this +} + +func NewPopulatedMyExtendable(r randyThetest, easy bool) *MyExtendable { + this := &MyExtendable{} + if r.Intn(10) != 0 { + v159 := int64(r.Int63()) + if r.Intn(2) == 0 { + v159 *= -1 + } + this.Field1 = &v159 + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + fieldNumber := r.Intn(100) + 100 + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 201) + } + return this +} + +func NewPopulatedOtherExtenable(r randyThetest, easy bool) *OtherExtenable { + this := &OtherExtenable{} + if r.Intn(10) != 0 { + v160 := int64(r.Int63()) + if r.Intn(2) == 0 { + v160 *= -1 + } + this.Field2 = &v160 + } + if r.Intn(10) != 0 { + v161 := int64(r.Int63()) + if r.Intn(2) == 0 { + v161 *= -1 + } + this.Field13 = &v161 + } + if r.Intn(10) != 0 { + this.M = NewPopulatedMyExtendable(r, easy) + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + eIndex := r.Intn(2) + fieldNumber := 0 + switch eIndex { + case 0: + fieldNumber = r.Intn(3) + 14 + case 1: + fieldNumber = r.Intn(3) + 10 + } + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 18) + } + return this +} + +func NewPopulatedNestedDefinition(r randyThetest, easy bool) *NestedDefinition { + this := &NestedDefinition{} + if r.Intn(10) != 0 { + v162 := int64(r.Int63()) + if r.Intn(2) == 0 { + v162 *= -1 + } + this.Field1 = &v162 + } + if r.Intn(10) != 0 { + v163 := NestedDefinition_NestedEnum([]int32{1}[r.Intn(1)]) + this.EnumField = &v163 + } + if r.Intn(10) != 0 { + this.NNM = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if r.Intn(10) != 0 { + this.NM = NewPopulatedNestedDefinition_NestedMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 5) + } + return this +} + +func NewPopulatedNestedDefinition_NestedMessage(r randyThetest, easy bool) *NestedDefinition_NestedMessage { + this := &NestedDefinition_NestedMessage{} + if r.Intn(10) != 0 { + v164 := uint64(uint64(r.Uint32())) + this.NestedField1 = &v164 + } + if r.Intn(10) != 0 { + this.NNM = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r randyThetest, easy bool) *NestedDefinition_NestedMessage_NestedNestedMsg { + this := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if r.Intn(10) != 0 { + v165 := randStringThetest(r) + this.NestedNestedField1 = &v165 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 11) + } + return this +} + +func NewPopulatedNestedScope(r randyThetest, easy bool) *NestedScope { + this := &NestedScope{} + if r.Intn(10) != 0 { + this.A = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if r.Intn(10) != 0 { + v166 := NestedDefinition_NestedEnum([]int32{1}[r.Intn(1)]) + this.B = &v166 + } + if r.Intn(10) != 0 { + this.C = NewPopulatedNestedDefinition_NestedMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 4) + } + return this +} + +func NewPopulatedNinOptNativeDefault(r randyThetest, easy bool) *NinOptNativeDefault { + this := &NinOptNativeDefault{} + if r.Intn(10) != 0 { + v167 := float64(r.Float64()) + if r.Intn(2) == 0 { + v167 *= -1 + } + this.Field1 = &v167 + } + if r.Intn(10) != 0 { + v168 := float32(r.Float32()) + if r.Intn(2) == 0 { + v168 *= -1 + } + this.Field2 = &v168 + } + if r.Intn(10) != 0 { + v169 := int32(r.Int31()) + if r.Intn(2) == 0 { + v169 *= -1 + } + this.Field3 = &v169 + } + if r.Intn(10) != 0 { + v170 := int64(r.Int63()) + if r.Intn(2) == 0 { + v170 *= -1 + } + this.Field4 = &v170 + } + if r.Intn(10) != 0 { + v171 := uint32(r.Uint32()) + this.Field5 = &v171 + } + if r.Intn(10) != 0 { + v172 := uint64(uint64(r.Uint32())) + this.Field6 = &v172 + } + if r.Intn(10) != 0 { + v173 := int32(r.Int31()) + if r.Intn(2) == 0 { + v173 *= -1 + } + this.Field7 = &v173 + } + if r.Intn(10) != 0 { + v174 := int64(r.Int63()) + if r.Intn(2) == 0 { + v174 *= -1 + } + this.Field8 = &v174 + } + if r.Intn(10) != 0 { + v175 := uint32(r.Uint32()) + this.Field9 = &v175 + } + if r.Intn(10) != 0 { + v176 := int32(r.Int31()) + if r.Intn(2) == 0 { + v176 *= -1 + } + this.Field10 = &v176 + } + if r.Intn(10) != 0 { + v177 := uint64(uint64(r.Uint32())) + this.Field11 = &v177 + } + if r.Intn(10) != 0 { + v178 := int64(r.Int63()) + if r.Intn(2) == 0 { + v178 *= -1 + } + this.Field12 = &v178 + } + if r.Intn(10) != 0 { + v179 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v179 + } + if r.Intn(10) != 0 { + v180 := randStringThetest(r) + this.Field14 = &v180 + } + if r.Intn(10) != 0 { + v181 := r.Intn(100) + this.Field15 = make([]byte, v181) + for i := 0; i < v181; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomContainer(r randyThetest, easy bool) *CustomContainer { + this := &CustomContainer{} + v182 := NewPopulatedNidOptCustom(r, easy) + this.CustomStruct = *v182 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedCustomNameNidOptNative(r randyThetest, easy bool) *CustomNameNidOptNative { + this := &CustomNameNidOptNative{} + this.FieldA = float64(r.Float64()) + if r.Intn(2) == 0 { + this.FieldA *= -1 + } + this.FieldB = float32(r.Float32()) + if r.Intn(2) == 0 { + this.FieldB *= -1 + } + this.FieldC = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldC *= -1 + } + this.FieldD = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldD *= -1 + } + this.FieldE = uint32(r.Uint32()) + this.FieldF = uint64(uint64(r.Uint32())) + this.FieldG = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldG *= -1 + } + this.FieldH = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldH *= -1 + } + this.FieldI = uint32(r.Uint32()) + this.FieldJ = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldJ *= -1 + } + this.FieldK = uint64(uint64(r.Uint32())) + this.FieldL = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldL *= -1 + } + this.FieldM = bool(bool(r.Intn(2) == 0)) + this.FieldN = randStringThetest(r) + v183 := r.Intn(100) + this.FieldO = make([]byte, v183) + for i := 0; i < v183; i++ { + this.FieldO[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinOptNative(r randyThetest, easy bool) *CustomNameNinOptNative { + this := &CustomNameNinOptNative{} + if r.Intn(10) != 0 { + v184 := float64(r.Float64()) + if r.Intn(2) == 0 { + v184 *= -1 + } + this.FieldA = &v184 + } + if r.Intn(10) != 0 { + v185 := float32(r.Float32()) + if r.Intn(2) == 0 { + v185 *= -1 + } + this.FieldB = &v185 + } + if r.Intn(10) != 0 { + v186 := int32(r.Int31()) + if r.Intn(2) == 0 { + v186 *= -1 + } + this.FieldC = &v186 + } + if r.Intn(10) != 0 { + v187 := int64(r.Int63()) + if r.Intn(2) == 0 { + v187 *= -1 + } + this.FieldD = &v187 + } + if r.Intn(10) != 0 { + v188 := uint32(r.Uint32()) + this.FieldE = &v188 + } + if r.Intn(10) != 0 { + v189 := uint64(uint64(r.Uint32())) + this.FieldF = &v189 + } + if r.Intn(10) != 0 { + v190 := int32(r.Int31()) + if r.Intn(2) == 0 { + v190 *= -1 + } + this.FieldG = &v190 + } + if r.Intn(10) != 0 { + v191 := int64(r.Int63()) + if r.Intn(2) == 0 { + v191 *= -1 + } + this.FieldH = &v191 + } + if r.Intn(10) != 0 { + v192 := uint32(r.Uint32()) + this.FieldI = &v192 + } + if r.Intn(10) != 0 { + v193 := int32(r.Int31()) + if r.Intn(2) == 0 { + v193 *= -1 + } + this.FieldJ = &v193 + } + if r.Intn(10) != 0 { + v194 := uint64(uint64(r.Uint32())) + this.FieldK = &v194 + } + if r.Intn(10) != 0 { + v195 := int64(r.Int63()) + if r.Intn(2) == 0 { + v195 *= -1 + } + this.FielL = &v195 + } + if r.Intn(10) != 0 { + v196 := bool(bool(r.Intn(2) == 0)) + this.FieldM = &v196 + } + if r.Intn(10) != 0 { + v197 := randStringThetest(r) + this.FieldN = &v197 + } + if r.Intn(10) != 0 { + v198 := r.Intn(100) + this.FieldO = make([]byte, v198) + for i := 0; i < v198; i++ { + this.FieldO[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinRepNative(r randyThetest, easy bool) *CustomNameNinRepNative { + this := &CustomNameNinRepNative{} + if r.Intn(10) != 0 { + v199 := r.Intn(100) + this.FieldA = make([]float64, v199) + for i := 0; i < v199; i++ { + this.FieldA[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.FieldA[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v200 := r.Intn(100) + this.FieldB = make([]float32, v200) + for i := 0; i < v200; i++ { + this.FieldB[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.FieldB[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v201 := r.Intn(100) + this.FieldC = make([]int32, v201) + for i := 0; i < v201; i++ { + this.FieldC[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldC[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v202 := r.Intn(100) + this.FieldD = make([]int64, v202) + for i := 0; i < v202; i++ { + this.FieldD[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldD[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v203 := r.Intn(100) + this.FieldE = make([]uint32, v203) + for i := 0; i < v203; i++ { + this.FieldE[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v204 := r.Intn(100) + this.FieldF = make([]uint64, v204) + for i := 0; i < v204; i++ { + this.FieldF[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v205 := r.Intn(100) + this.FieldG = make([]int32, v205) + for i := 0; i < v205; i++ { + this.FieldG[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldG[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v206 := r.Intn(100) + this.FieldH = make([]int64, v206) + for i := 0; i < v206; i++ { + this.FieldH[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldH[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v207 := r.Intn(100) + this.FieldI = make([]uint32, v207) + for i := 0; i < v207; i++ { + this.FieldI[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v208 := r.Intn(100) + this.FieldJ = make([]int32, v208) + for i := 0; i < v208; i++ { + this.FieldJ[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldJ[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v209 := r.Intn(100) + this.FieldK = make([]uint64, v209) + for i := 0; i < v209; i++ { + this.FieldK[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v210 := r.Intn(100) + this.FieldL = make([]int64, v210) + for i := 0; i < v210; i++ { + this.FieldL[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldL[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v211 := r.Intn(100) + this.FieldM = make([]bool, v211) + for i := 0; i < v211; i++ { + this.FieldM[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v212 := r.Intn(10) + this.FieldN = make([]string, v212) + for i := 0; i < v212; i++ { + this.FieldN[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v213 := r.Intn(100) + this.FieldO = make([][]byte, v213) + for i := 0; i < v213; i++ { + v214 := r.Intn(100) + this.FieldO[i] = make([]byte, v214) + for j := 0; j < v214; j++ { + this.FieldO[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinStruct(r randyThetest, easy bool) *CustomNameNinStruct { + this := &CustomNameNinStruct{} + if r.Intn(10) != 0 { + v215 := float64(r.Float64()) + if r.Intn(2) == 0 { + v215 *= -1 + } + this.FieldA = &v215 + } + if r.Intn(10) != 0 { + v216 := float32(r.Float32()) + if r.Intn(2) == 0 { + v216 *= -1 + } + this.FieldB = &v216 + } + if r.Intn(10) != 0 { + this.FieldC = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v217 := r.Intn(10) + this.FieldD = make([]*NinOptNative, v217) + for i := 0; i < v217; i++ { + this.FieldD[i] = NewPopulatedNinOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v218 := uint64(uint64(r.Uint32())) + this.FieldE = &v218 + } + if r.Intn(10) != 0 { + v219 := int32(r.Int31()) + if r.Intn(2) == 0 { + v219 *= -1 + } + this.FieldF = &v219 + } + if r.Intn(10) != 0 { + this.FieldG = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v220 := bool(bool(r.Intn(2) == 0)) + this.FieldH = &v220 + } + if r.Intn(10) != 0 { + v221 := randStringThetest(r) + this.FieldI = &v221 + } + if r.Intn(10) != 0 { + v222 := r.Intn(100) + this.FieldJ = make([]byte, v222) + for i := 0; i < v222; i++ { + this.FieldJ[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameCustomType(r randyThetest, easy bool) *CustomNameCustomType { + this := &CustomNameCustomType{} + if r.Intn(10) != 0 { + this.FieldA = NewPopulatedUuid(r) + } + if r.Intn(10) != 0 { + this.FieldB = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + } + if r.Intn(10) != 0 { + v223 := r.Intn(10) + this.FieldC = make([]Uuid, v223) + for i := 0; i < v223; i++ { + v224 := NewPopulatedUuid(r) + this.FieldC[i] = *v224 + } + } + if r.Intn(10) != 0 { + v225 := r.Intn(10) + this.FieldD = make([]github_com_gogo_protobuf_test_custom.Uint128, v225) + for i := 0; i < v225; i++ { + v226 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.FieldD[i] = *v226 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 5) + } + return this +} + +func NewPopulatedCustomNameNinEmbeddedStructUnion(r randyThetest, easy bool) *CustomNameNinEmbeddedStructUnion { + this := &CustomNameNinEmbeddedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + case 1: + this.FieldA = NewPopulatedNinOptNative(r, easy) + case 2: + v227 := bool(bool(r.Intn(2) == 0)) + this.FieldB = &v227 + } + return this +} + +func NewPopulatedCustomNameEnum(r randyThetest, easy bool) *CustomNameEnum { + this := &CustomNameEnum{} + if r.Intn(10) != 0 { + v228 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.FieldA = &v228 + } + if r.Intn(10) != 0 { + v229 := r.Intn(10) + this.FieldB = make([]TheTestEnum, v229) + for i := 0; i < v229; i++ { + this.FieldB[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNoExtensionsMap(r randyThetest, easy bool) *NoExtensionsMap { + this := &NoExtensionsMap{} + if r.Intn(10) != 0 { + v230 := int64(r.Int63()) + if r.Intn(2) == 0 { + v230 *= -1 + } + this.Field1 = &v230 + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + fieldNumber := r.Intn(100) + 100 + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 201) + } + return this +} + +func NewPopulatedUnrecognized(r randyThetest, easy bool) *Unrecognized { + this := &Unrecognized{} + if r.Intn(10) != 0 { + v231 := randStringThetest(r) + this.Field1 = &v231 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedUnrecognizedWithInner(r randyThetest, easy bool) *UnrecognizedWithInner { + this := &UnrecognizedWithInner{} + if r.Intn(10) != 0 { + v232 := r.Intn(10) + this.Embedded = make([]*UnrecognizedWithInner_Inner, v232) + for i := 0; i < v232; i++ { + this.Embedded[i] = NewPopulatedUnrecognizedWithInner_Inner(r, easy) + } + } + if r.Intn(10) != 0 { + v233 := randStringThetest(r) + this.Field2 = &v233 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedUnrecognizedWithInner_Inner(r randyThetest, easy bool) *UnrecognizedWithInner_Inner { + this := &UnrecognizedWithInner_Inner{} + if r.Intn(10) != 0 { + v234 := uint32(r.Uint32()) + this.Field1 = &v234 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedUnrecognizedWithEmbed(r randyThetest, easy bool) *UnrecognizedWithEmbed { + this := &UnrecognizedWithEmbed{} + v235 := NewPopulatedUnrecognizedWithEmbed_Embedded(r, easy) + this.UnrecognizedWithEmbed_Embedded = *v235 + if r.Intn(10) != 0 { + v236 := randStringThetest(r) + this.Field2 = &v236 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedUnrecognizedWithEmbed_Embedded(r randyThetest, easy bool) *UnrecognizedWithEmbed_Embedded { + this := &UnrecognizedWithEmbed_Embedded{} + if r.Intn(10) != 0 { + v237 := uint32(r.Uint32()) + this.Field1 = &v237 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +type randyThetest interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneThetest(r randyThetest) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringThetest(r randyThetest) string { + v238 := r.Intn(100) + tmps := make([]rune, v238) + for i := 0; i < v238; i++ { + tmps[i] = randUTF8RuneThetest(r) + } + return string(tmps) +} +func randUnrecognizedThetest(r randyThetest, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldThetest(data, r, fieldNumber, wire) + } + return data +} +func randFieldThetest(data []byte, r randyThetest, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateThetest(data, uint64(key)) + v239 := r.Int63() + if r.Intn(2) == 0 { + v239 *= -1 + } + data = encodeVarintPopulateThetest(data, uint64(v239)) + case 1: + data = encodeVarintPopulateThetest(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateThetest(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateThetest(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateThetest(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateThetest(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *NidOptNative) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + n += 1 + sovThetest(uint64(m.Field3)) + n += 1 + sovThetest(uint64(m.Field4)) + n += 1 + sovThetest(uint64(m.Field5)) + n += 1 + sovThetest(uint64(m.Field6)) + n += 1 + sozThetest(uint64(m.Field7)) + n += 1 + sozThetest(uint64(m.Field8)) + n += 5 + n += 5 + n += 9 + n += 9 + n += 2 + l = len(m.Field14) + n += 1 + l + sovThetest(uint64(l)) + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNative) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + n += 1 + sozThetest(uint64(*m.Field8)) + } + if m.Field9 != nil { + n += 5 + } + if m.Field10 != nil { + n += 5 + } + if m.Field11 != nil { + n += 9 + } + if m.Field12 != nil { + n += 9 + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field5) > 0 { + for _, e := range m.Field5 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field9) > 0 { + n += 5 * len(m.Field9) + } + if len(m.Field10) > 0 { + n += 5 * len(m.Field10) + } + if len(m.Field11) > 0 { + n += 9 * len(m.Field11) + } + if len(m.Field12) > 0 { + n += 9 * len(m.Field12) + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field5) > 0 { + for _, e := range m.Field5 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field9) > 0 { + n += 5 * len(m.Field9) + } + if len(m.Field10) > 0 { + n += 5 * len(m.Field10) + } + if len(m.Field11) > 0 { + n += 9 * len(m.Field11) + } + if len(m.Field12) > 0 { + n += 9 * len(m.Field12) + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepPackedNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 1 + sovThetest(uint64(len(m.Field1)*8)) + len(m.Field1)*8 + } + if len(m.Field2) > 0 { + n += 1 + sovThetest(uint64(len(m.Field2)*4)) + len(m.Field2)*4 + } + if len(m.Field3) > 0 { + l = 0 + for _, e := range m.Field3 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field4) > 0 { + l = 0 + for _, e := range m.Field4 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field5) > 0 { + l = 0 + for _, e := range m.Field5 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field6) > 0 { + l = 0 + for _, e := range m.Field6 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field7) > 0 { + l = 0 + for _, e := range m.Field7 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field8) > 0 { + l = 0 + for _, e := range m.Field8 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field9) > 0 { + n += 1 + sovThetest(uint64(len(m.Field9)*4)) + len(m.Field9)*4 + } + if len(m.Field10) > 0 { + n += 1 + sovThetest(uint64(len(m.Field10)*4)) + len(m.Field10)*4 + } + if len(m.Field11) > 0 { + n += 1 + sovThetest(uint64(len(m.Field11)*8)) + len(m.Field11)*8 + } + if len(m.Field12) > 0 { + n += 1 + sovThetest(uint64(len(m.Field12)*8)) + len(m.Field12)*8 + } + if len(m.Field13) > 0 { + n += 1 + sovThetest(uint64(len(m.Field13))) + len(m.Field13)*1 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepPackedNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 1 + sovThetest(uint64(len(m.Field1)*8)) + len(m.Field1)*8 + } + if len(m.Field2) > 0 { + n += 1 + sovThetest(uint64(len(m.Field2)*4)) + len(m.Field2)*4 + } + if len(m.Field3) > 0 { + l = 0 + for _, e := range m.Field3 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field4) > 0 { + l = 0 + for _, e := range m.Field4 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field5) > 0 { + l = 0 + for _, e := range m.Field5 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field6) > 0 { + l = 0 + for _, e := range m.Field6 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field7) > 0 { + l = 0 + for _, e := range m.Field7 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field8) > 0 { + l = 0 + for _, e := range m.Field8 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field9) > 0 { + n += 1 + sovThetest(uint64(len(m.Field9)*4)) + len(m.Field9)*4 + } + if len(m.Field10) > 0 { + n += 1 + sovThetest(uint64(len(m.Field10)*4)) + len(m.Field10)*4 + } + if len(m.Field11) > 0 { + n += 1 + sovThetest(uint64(len(m.Field11)*8)) + len(m.Field11)*8 + } + if len(m.Field12) > 0 { + n += 1 + sovThetest(uint64(len(m.Field12)*8)) + len(m.Field12)*8 + } + if len(m.Field13) > 0 { + n += 1 + sovThetest(uint64(len(m.Field13))) + len(m.Field13)*1 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptStruct) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + n += 1 + sovThetest(uint64(m.Field6)) + n += 1 + sozThetest(uint64(m.Field7)) + l = m.Field8.Size() + n += 1 + l + sovThetest(uint64(l)) + n += 2 + l = len(m.Field14) + n += 1 + l + sovThetest(uint64(l)) + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptStruct) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field4 != nil { + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + l = m.Field8.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepStruct) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepStruct) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidEmbeddedStruct) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + n += 3 + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinEmbeddedStruct) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field200 != nil { + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.Field210 != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidNestedStruct) Size() (n int) { + var l int + _ = l + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + if len(m.Field2) > 0 { + for _, e := range m.Field2 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinNestedStruct) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.Field2) > 0 { + for _, e := range m.Field2 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptCustom) Size() (n int) { + var l int + _ = l + l = m.Id.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomDash) Size() (n int) { + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptCustom) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepCustom) Size() (n int) { + var l int + _ = l + if len(m.Id) > 0 { + for _, e := range m.Id { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Value) > 0 { + for _, e := range m.Value { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepCustom) Size() (n int) { + var l int + _ = l + if len(m.Id) > 0 { + for _, e := range m.Id { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Value) > 0 { + for _, e := range m.Value { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNativeUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptStructUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field4 != nil { + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinEmbeddedStructUnion) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field200 != nil { + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.Field210 != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinNestedStructUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field2 != nil { + l = m.Field2.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Tree) Size() (n int) { + var l int + _ = l + if m.Or != nil { + l = m.Or.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.And != nil { + l = m.And.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Leaf != nil { + l = m.Leaf.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *OrBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AndBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Leaf) Size() (n int) { + var l int + _ = l + n += 1 + sovThetest(uint64(m.Value)) + l = len(m.StrValue) + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DeepTree) Size() (n int) { + var l int + _ = l + if m.Down != nil { + l = m.Down.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.And != nil { + l = m.And.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Leaf != nil { + l = m.Leaf.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ADeepBranch) Size() (n int) { + var l int + _ = l + l = m.Down.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AndDeepBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DeepLeaf) Size() (n int) { + var l int + _ = l + l = m.Tree.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Nil) Size() (n int) { + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptEnum) Size() (n int) { + var l int + _ = l + n += 1 + sovThetest(uint64(m.Field1)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptEnum) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepEnum) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + for _, e := range m.Field1 { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepEnum) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + for _, e := range m.Field1 { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptEnumDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AnotherNinOptEnum) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AnotherNinOptEnumDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Timer) Size() (n int) { + var l int + _ = l + n += 9 + n += 9 + if m.Data != nil { + l = len(m.Data) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *MyExtendable) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + n += github_com_gogo_protobuf_proto.SizeOfExtensionMap(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *OtherExtenable) Size() (n int) { + var l int + _ = l + if m.Field2 != nil { + n += 1 + sovThetest(uint64(*m.Field2)) + } + if m.Field13 != nil { + n += 1 + sovThetest(uint64(*m.Field13)) + } + if m.M != nil { + l = m.M.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_extensions != nil { + n += github_com_gogo_protobuf_proto.SizeOfExtensionMap(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.EnumField != nil { + n += 1 + sovThetest(uint64(*m.EnumField)) + } + if m.NNM != nil { + l = m.NNM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.NM != nil { + l = m.NM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition_NestedMessage) Size() (n int) { + var l int + _ = l + if m.NestedField1 != nil { + n += 9 + } + if m.NNM != nil { + l = m.NNM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Size() (n int) { + var l int + _ = l + if m.NestedNestedField1 != nil { + l = len(*m.NestedNestedField1) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedScope) Size() (n int) { + var l int + _ = l + if m.A != nil { + l = m.A.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.B != nil { + n += 1 + sovThetest(uint64(*m.B)) + } + if m.C != nil { + l = m.C.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNativeDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + n += 1 + sozThetest(uint64(*m.Field8)) + } + if m.Field9 != nil { + n += 5 + } + if m.Field10 != nil { + n += 5 + } + if m.Field11 != nil { + n += 9 + } + if m.Field12 != nil { + n += 9 + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomContainer) Size() (n int) { + var l int + _ = l + l = m.CustomStruct.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNidOptNative) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + n += 1 + sovThetest(uint64(m.FieldC)) + n += 1 + sovThetest(uint64(m.FieldD)) + n += 1 + sovThetest(uint64(m.FieldE)) + n += 1 + sovThetest(uint64(m.FieldF)) + n += 1 + sozThetest(uint64(m.FieldG)) + n += 1 + sozThetest(uint64(m.FieldH)) + n += 5 + n += 5 + n += 9 + n += 9 + n += 2 + l = len(m.FieldN) + n += 1 + l + sovThetest(uint64(l)) + if m.FieldO != nil { + l = len(m.FieldO) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinOptNative) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 9 + } + if m.FieldB != nil { + n += 5 + } + if m.FieldC != nil { + n += 1 + sovThetest(uint64(*m.FieldC)) + } + if m.FieldD != nil { + n += 1 + sovThetest(uint64(*m.FieldD)) + } + if m.FieldE != nil { + n += 1 + sovThetest(uint64(*m.FieldE)) + } + if m.FieldF != nil { + n += 1 + sovThetest(uint64(*m.FieldF)) + } + if m.FieldG != nil { + n += 1 + sozThetest(uint64(*m.FieldG)) + } + if m.FieldH != nil { + n += 1 + sozThetest(uint64(*m.FieldH)) + } + if m.FieldI != nil { + n += 5 + } + if m.FieldJ != nil { + n += 5 + } + if m.FieldK != nil { + n += 9 + } + if m.FielL != nil { + n += 9 + } + if m.FieldM != nil { + n += 2 + } + if m.FieldN != nil { + l = len(*m.FieldN) + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldO != nil { + l = len(m.FieldO) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinRepNative) Size() (n int) { + var l int + _ = l + if len(m.FieldA) > 0 { + n += 9 * len(m.FieldA) + } + if len(m.FieldB) > 0 { + n += 5 * len(m.FieldB) + } + if len(m.FieldC) > 0 { + for _, e := range m.FieldC { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldE) > 0 { + for _, e := range m.FieldE { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldF) > 0 { + for _, e := range m.FieldF { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldG) > 0 { + for _, e := range m.FieldG { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.FieldH) > 0 { + for _, e := range m.FieldH { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.FieldI) > 0 { + n += 5 * len(m.FieldI) + } + if len(m.FieldJ) > 0 { + n += 5 * len(m.FieldJ) + } + if len(m.FieldK) > 0 { + n += 9 * len(m.FieldK) + } + if len(m.FieldL) > 0 { + n += 9 * len(m.FieldL) + } + if len(m.FieldM) > 0 { + n += 2 * len(m.FieldM) + } + if len(m.FieldN) > 0 { + for _, s := range m.FieldN { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.FieldO) > 0 { + for _, b := range m.FieldO { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinStruct) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 9 + } + if m.FieldB != nil { + n += 5 + } + if m.FieldC != nil { + l = m.FieldC.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.FieldE != nil { + n += 1 + sovThetest(uint64(*m.FieldE)) + } + if m.FieldF != nil { + n += 1 + sozThetest(uint64(*m.FieldF)) + } + if m.FieldG != nil { + l = m.FieldG.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldH != nil { + n += 2 + } + if m.FieldI != nil { + l = len(*m.FieldI) + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldJ != nil { + l = len(m.FieldJ) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameCustomType) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + l = m.FieldA.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldB != nil { + l = m.FieldB.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.FieldC) > 0 { + for _, e := range m.FieldC { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinEmbeddedStructUnion) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldA != nil { + l = m.FieldA.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.FieldB != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameEnum) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 1 + sovThetest(uint64(*m.FieldA)) + } + if len(m.FieldB) > 0 { + for _, e := range m.FieldB { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NoExtensionsMap) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + n += len(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Unrecognized) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = len(*m.Field1) + n += 1 + l + sovThetest(uint64(l)) + } + return n +} + +func (m *UnrecognizedWithInner) Size() (n int) { + var l int + _ = l + if len(m.Embedded) > 0 { + for _, e := range m.Embedded { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.Field2 != nil { + l = len(*m.Field2) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UnrecognizedWithInner_Inner) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + return n +} + +func (m *UnrecognizedWithEmbed) Size() (n int) { + var l int + _ = l + l = m.UnrecognizedWithEmbed_Embedded.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.Field2 != nil { + l = len(*m.Field2) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UnrecognizedWithEmbed_Embedded) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + return n +} + +func sovThetest(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozThetest(x uint64) (n int) { + return sovThetest(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *NidOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNative{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + valueToStringThetest(this.Field8) + `,`, + `Field9:` + valueToStringThetest(this.Field9) + `,`, + `Field10:` + valueToStringThetest(this.Field10) + `,`, + `Field11:` + valueToStringThetest(this.Field11) + `,`, + `Field12:` + valueToStringThetest(this.Field12) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepPackedNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepPackedNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepPackedNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepPackedNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(strings.Replace(this.Field3.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field4:` + strings.Replace(strings.Replace(this.Field4.String(), "NinOptNative", "NinOptNative", 1), `&`, ``, 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(strings.Replace(this.Field8.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptStruct{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field4:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1), `&`, ``, 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidEmbeddedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidEmbeddedStruct{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(strings.Replace(this.Field200.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field210:` + fmt.Sprintf("%v", this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinEmbeddedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinEmbeddedStruct{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(fmt.Sprintf("%v", this.Field200), "NidOptNative", "NidOptNative", 1) + `,`, + `Field210:` + valueToStringThetest(this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidNestedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidNestedStruct{`, + `Field1:` + strings.Replace(strings.Replace(this.Field1.String(), "NidOptStruct", "NidOptStruct", 1), `&`, ``, 1) + `,`, + `Field2:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field2), "NidRepStruct", "NidRepStruct", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinNestedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinNestedStruct{`, + `Field1:` + strings.Replace(fmt.Sprintf("%v", this.Field1), "NinOptStruct", "NinOptStruct", 1) + `,`, + `Field2:` + strings.Replace(fmt.Sprintf("%v", this.Field2), "NinRepStruct", "NinRepStruct", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomDash) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomDash{`, + `Value:` + valueToStringThetest(this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptCustom{`, + `Id:` + valueToStringThetest(this.Id) + `,`, + `Value:` + valueToStringThetest(this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNativeUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNativeUnion{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptStructUnion{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinEmbeddedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinEmbeddedStructUnion{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(fmt.Sprintf("%v", this.Field200), "NinOptNative", "NinOptNative", 1) + `,`, + `Field210:` + valueToStringThetest(this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinNestedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinNestedStructUnion{`, + `Field1:` + strings.Replace(fmt.Sprintf("%v", this.Field1), "NinOptNativeUnion", "NinOptNativeUnion", 1) + `,`, + `Field2:` + strings.Replace(fmt.Sprintf("%v", this.Field2), "NinOptStructUnion", "NinOptStructUnion", 1) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NinEmbeddedStructUnion", "NinEmbeddedStructUnion", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Tree) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Tree{`, + `Or:` + strings.Replace(fmt.Sprintf("%v", this.Or), "OrBranch", "OrBranch", 1) + `,`, + `And:` + strings.Replace(fmt.Sprintf("%v", this.And), "AndBranch", "AndBranch", 1) + `,`, + `Leaf:` + strings.Replace(fmt.Sprintf("%v", this.Leaf), "Leaf", "Leaf", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OrBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OrBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AndBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AndBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Leaf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Leaf{`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `StrValue:` + fmt.Sprintf("%v", this.StrValue) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *DeepTree) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DeepTree{`, + `Down:` + strings.Replace(fmt.Sprintf("%v", this.Down), "ADeepBranch", "ADeepBranch", 1) + `,`, + `And:` + strings.Replace(fmt.Sprintf("%v", this.And), "AndDeepBranch", "AndDeepBranch", 1) + `,`, + `Leaf:` + strings.Replace(fmt.Sprintf("%v", this.Leaf), "DeepLeaf", "DeepLeaf", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ADeepBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ADeepBranch{`, + `Down:` + strings.Replace(strings.Replace(this.Down.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AndDeepBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AndDeepBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *DeepLeaf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DeepLeaf{`, + `Tree:` + strings.Replace(strings.Replace(this.Tree.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Nil) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Nil{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptEnum{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptEnumDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptEnumDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AnotherNinOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnotherNinOptEnum{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AnotherNinOptEnumDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnotherNinOptEnumDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Timer) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Timer{`, + `Time1:` + fmt.Sprintf("%v", this.Time1) + `,`, + `Time2:` + fmt.Sprintf("%v", this.Time2) + `,`, + `Data:` + fmt.Sprintf("%v", this.Data) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *MyExtendable) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&MyExtendable{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsMap(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OtherExtenable) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OtherExtenable{`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `M:` + strings.Replace(fmt.Sprintf("%v", this.M), "MyExtendable", "MyExtendable", 1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsMap(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `EnumField:` + valueToStringThetest(this.EnumField) + `,`, + `NNM:` + strings.Replace(fmt.Sprintf("%v", this.NNM), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `NM:` + strings.Replace(fmt.Sprintf("%v", this.NM), "NestedDefinition_NestedMessage", "NestedDefinition_NestedMessage", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition_NestedMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition_NestedMessage{`, + `NestedField1:` + valueToStringThetest(this.NestedField1) + `,`, + `NNM:` + strings.Replace(fmt.Sprintf("%v", this.NNM), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition_NestedMessage_NestedNestedMsg{`, + `NestedNestedField1:` + valueToStringThetest(this.NestedNestedField1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedScope) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedScope{`, + `A:` + strings.Replace(fmt.Sprintf("%v", this.A), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `B:` + valueToStringThetest(this.B) + `,`, + `C:` + strings.Replace(fmt.Sprintf("%v", this.C), "NestedDefinition_NestedMessage", "NestedDefinition_NestedMessage", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNativeDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNativeDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + valueToStringThetest(this.Field8) + `,`, + `Field9:` + valueToStringThetest(this.Field9) + `,`, + `Field10:` + valueToStringThetest(this.Field10) + `,`, + `Field11:` + valueToStringThetest(this.Field11) + `,`, + `Field12:` + valueToStringThetest(this.Field12) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomContainer) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomContainer{`, + `CustomStruct:` + strings.Replace(strings.Replace(this.CustomStruct.String(), "NidOptCustom", "NidOptCustom", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNidOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNidOptNative{`, + `FieldA:` + fmt.Sprintf("%v", this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `FieldE:` + fmt.Sprintf("%v", this.FieldE) + `,`, + `FieldF:` + fmt.Sprintf("%v", this.FieldF) + `,`, + `FieldG:` + fmt.Sprintf("%v", this.FieldG) + `,`, + `FieldH:` + fmt.Sprintf("%v", this.FieldH) + `,`, + `FieldI:` + fmt.Sprintf("%v", this.FieldI) + `,`, + `FieldJ:` + fmt.Sprintf("%v", this.FieldJ) + `,`, + `FieldK:` + fmt.Sprintf("%v", this.FieldK) + `,`, + `FieldL:` + fmt.Sprintf("%v", this.FieldL) + `,`, + `FieldM:` + fmt.Sprintf("%v", this.FieldM) + `,`, + `FieldN:` + fmt.Sprintf("%v", this.FieldN) + `,`, + `FieldO:` + fmt.Sprintf("%v", this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinOptNative{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + valueToStringThetest(this.FieldC) + `,`, + `FieldD:` + valueToStringThetest(this.FieldD) + `,`, + `FieldE:` + valueToStringThetest(this.FieldE) + `,`, + `FieldF:` + valueToStringThetest(this.FieldF) + `,`, + `FieldG:` + valueToStringThetest(this.FieldG) + `,`, + `FieldH:` + valueToStringThetest(this.FieldH) + `,`, + `FieldI:` + valueToStringThetest(this.FieldI) + `,`, + `FieldJ:` + valueToStringThetest(this.FieldJ) + `,`, + `FieldK:` + valueToStringThetest(this.FieldK) + `,`, + `FielL:` + valueToStringThetest(this.FielL) + `,`, + `FieldM:` + valueToStringThetest(this.FieldM) + `,`, + `FieldN:` + valueToStringThetest(this.FieldN) + `,`, + `FieldO:` + valueToStringThetest(this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinRepNative{`, + `FieldA:` + fmt.Sprintf("%v", this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `FieldE:` + fmt.Sprintf("%v", this.FieldE) + `,`, + `FieldF:` + fmt.Sprintf("%v", this.FieldF) + `,`, + `FieldG:` + fmt.Sprintf("%v", this.FieldG) + `,`, + `FieldH:` + fmt.Sprintf("%v", this.FieldH) + `,`, + `FieldI:` + fmt.Sprintf("%v", this.FieldI) + `,`, + `FieldJ:` + fmt.Sprintf("%v", this.FieldJ) + `,`, + `FieldK:` + fmt.Sprintf("%v", this.FieldK) + `,`, + `FieldL:` + fmt.Sprintf("%v", this.FieldL) + `,`, + `FieldM:` + fmt.Sprintf("%v", this.FieldM) + `,`, + `FieldN:` + fmt.Sprintf("%v", this.FieldN) + `,`, + `FieldO:` + fmt.Sprintf("%v", this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinStruct{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + strings.Replace(fmt.Sprintf("%v", this.FieldC), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldD:` + strings.Replace(fmt.Sprintf("%v", this.FieldD), "NinOptNative", "NinOptNative", 1) + `,`, + `FieldE:` + valueToStringThetest(this.FieldE) + `,`, + `FieldF:` + valueToStringThetest(this.FieldF) + `,`, + `FieldG:` + strings.Replace(fmt.Sprintf("%v", this.FieldG), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldH:` + valueToStringThetest(this.FieldH) + `,`, + `FieldI:` + valueToStringThetest(this.FieldI) + `,`, + `FieldJ:` + valueToStringThetest(this.FieldJ) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameCustomType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameCustomType{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinEmbeddedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinEmbeddedStructUnion{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldA:` + strings.Replace(fmt.Sprintf("%v", this.FieldA), "NinOptNative", "NinOptNative", 1) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameEnum{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NoExtensionsMap) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NoExtensionsMap{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsBytes(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Unrecognized) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Unrecognized{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithInner) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithInner{`, + `Embedded:` + strings.Replace(fmt.Sprintf("%v", this.Embedded), "UnrecognizedWithInner_Inner", "UnrecognizedWithInner_Inner", 1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithInner_Inner) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithInner_Inner{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithEmbed) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithEmbed{`, + `UnrecognizedWithEmbed_Embedded:` + strings.Replace(strings.Replace(this.UnrecognizedWithEmbed_Embedded.String(), "UnrecognizedWithEmbed_Embedded", "UnrecognizedWithEmbed_Embedded", 1), `&`, ``, 1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithEmbed_Embedded) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithEmbed_Embedded{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func valueToStringThetest(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (this *NinOptNativeUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + if this.Field4 != nil { + return this.Field4 + } + if this.Field5 != nil { + return this.Field5 + } + if this.Field6 != nil { + return this.Field6 + } + if this.Field13 != nil { + return this.Field13 + } + if this.Field14 != nil { + return this.Field14 + } + if this.Field15 != nil { + return this.Field15 + } + return nil +} + +func (this *NinOptNativeUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *float64: + this.Field1 = vt + case *float32: + this.Field2 = vt + case *int32: + this.Field3 = vt + case *int64: + this.Field4 = vt + case *uint32: + this.Field5 = vt + case *uint64: + this.Field6 = vt + case *bool: + this.Field13 = vt + case *string: + this.Field14 = vt + case []byte: + this.Field15 = vt + default: + return false + } + return true +} +func (this *NinOptStructUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + if this.Field4 != nil { + return this.Field4 + } + if this.Field6 != nil { + return this.Field6 + } + if this.Field7 != nil { + return this.Field7 + } + if this.Field13 != nil { + return this.Field13 + } + if this.Field14 != nil { + return this.Field14 + } + if this.Field15 != nil { + return this.Field15 + } + return nil +} + +func (this *NinOptStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *float64: + this.Field1 = vt + case *float32: + this.Field2 = vt + case *NidOptNative: + this.Field3 = vt + case *NinOptNative: + this.Field4 = vt + case *uint64: + this.Field6 = vt + case *int32: + this.Field7 = vt + case *bool: + this.Field13 = vt + case *string: + this.Field14 = vt + case []byte: + this.Field15 = vt + default: + return false + } + return true +} +func (this *NinEmbeddedStructUnion) GetValue() interface{} { + if this.NidOptNative != nil { + return this.NidOptNative + } + if this.Field200 != nil { + return this.Field200 + } + if this.Field210 != nil { + return this.Field210 + } + return nil +} + +func (this *NinEmbeddedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NidOptNative: + this.NidOptNative = vt + case *NinOptNative: + this.Field200 = vt + case *bool: + this.Field210 = vt + default: + return false + } + return true +} +func (this *NinNestedStructUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + return nil +} + +func (this *NinNestedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NinOptNativeUnion: + this.Field1 = vt + case *NinOptStructUnion: + this.Field2 = vt + case *NinEmbeddedStructUnion: + this.Field3 = vt + default: + this.Field1 = new(NinOptNativeUnion) + if set := this.Field1.SetValue(value); set { + return true + } + this.Field1 = nil + this.Field2 = new(NinOptStructUnion) + if set := this.Field2.SetValue(value); set { + return true + } + this.Field2 = nil + this.Field3 = new(NinEmbeddedStructUnion) + if set := this.Field3.SetValue(value); set { + return true + } + this.Field3 = nil + return false + } + return true +} +func (this *Tree) GetValue() interface{} { + if this.Or != nil { + return this.Or + } + if this.And != nil { + return this.And + } + if this.Leaf != nil { + return this.Leaf + } + return nil +} + +func (this *Tree) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *OrBranch: + this.Or = vt + case *AndBranch: + this.And = vt + case *Leaf: + this.Leaf = vt + default: + return false + } + return true +} +func (this *DeepTree) GetValue() interface{} { + if this.Down != nil { + return this.Down + } + if this.And != nil { + return this.And + } + if this.Leaf != nil { + return this.Leaf + } + return nil +} + +func (this *DeepTree) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *ADeepBranch: + this.Down = vt + case *AndDeepBranch: + this.And = vt + case *DeepLeaf: + this.Leaf = vt + default: + return false + } + return true +} +func (this *CustomNameNinEmbeddedStructUnion) GetValue() interface{} { + if this.NidOptNative != nil { + return this.NidOptNative + } + if this.FieldA != nil { + return this.FieldA + } + if this.FieldB != nil { + return this.FieldB + } + return nil +} + +func (this *CustomNameNinEmbeddedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NidOptNative: + this.NidOptNative = vt + case *NinOptNative: + this.FieldA = vt + case *bool: + this.FieldB = vt + default: + return false + } + return true +} +func (m *NidOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = m.Field1 + i += 8 + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = m.Field2 + i += 4 + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3)) + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field4)) + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field5)) + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field6)) + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31)))) + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(m.Field8)<<1)^uint64((m.Field8>>63)))) + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = m.Field9 + i += 4 + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = m.Field10 + i += 4 + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = m.Field11 + i += 8 + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = m.Field12 + i += 8 + data[i] = 0x68 + i++ + if m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field14))) + i += copy(data[i:], m.Field14) + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = *m.Field1 + i += 8 + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = *m.Field2 + i += 4 + } + if m.Field3 != nil { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field3)) + } + if m.Field4 != nil { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field4)) + } + if m.Field5 != nil { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field5)) + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field8 != nil { + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(*m.Field8)<<1)^uint64((*m.Field8>>63)))) + } + if m.Field9 != nil { + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = *m.Field9 + i += 4 + } + if m.Field10 != nil { + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = *m.Field10 + i += 4 + } + if m.Field11 != nil { + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = *m.Field11 + i += 8 + } + if m.Field12 != nil { + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = *m.Field12 + i += 8 + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field3) > 0 { + for _, num := range m.Field3 { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field4) > 0 { + for _, num := range m.Field4 { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field5) > 0 { + for _, num := range m.Field5 { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field6) > 0 { + for _, num := range m.Field6 { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x38 + i++ + x1 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x1 >= 1<<7 { + data[i] = uint8(uint64(x1)&0x7f | 0x80) + x1 >>= 7 + i++ + } + data[i] = uint8(x1) + i++ + } + } + if len(m.Field8) > 0 { + for _, num := range m.Field8 { + data[i] = 0x40 + i++ + x2 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x2 >= 1<<7 { + data[i] = uint8(uint64(x2)&0x7f | 0x80) + x2 >>= 7 + i++ + } + data[i] = uint8(x2) + i++ + } + } + if len(m.Field9) > 0 { + for _, num := range m.Field9 { + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field10) > 0 { + for _, num := range m.Field10 { + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field11) > 0 { + for _, num := range m.Field11 { + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field12) > 0 { + for _, num := range m.Field12 { + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field13) > 0 { + for _, b := range m.Field13 { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field3) > 0 { + for _, num := range m.Field3 { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field4) > 0 { + for _, num := range m.Field4 { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field5) > 0 { + for _, num := range m.Field5 { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field6) > 0 { + for _, num := range m.Field6 { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x38 + i++ + x3 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x3 >= 1<<7 { + data[i] = uint8(uint64(x3)&0x7f | 0x80) + x3 >>= 7 + i++ + } + data[i] = uint8(x3) + i++ + } + } + if len(m.Field8) > 0 { + for _, num := range m.Field8 { + data[i] = 0x40 + i++ + x4 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x4 >= 1<<7 { + data[i] = uint8(uint64(x4)&0x7f | 0x80) + x4 >>= 7 + i++ + } + data[i] = uint8(x4) + i++ + } + } + if len(m.Field9) > 0 { + for _, num := range m.Field9 { + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field10) > 0 { + for _, num := range m.Field10 { + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field11) > 0 { + for _, num := range m.Field11 { + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field12) > 0 { + for _, num := range m.Field12 { + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field13) > 0 { + for _, b := range m.Field13 { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepPackedNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepPackedNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field1)*8)) + for _, num := range m.Field1 { + *(*float64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field2) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field2)*4)) + for _, num := range m.Field2 { + *(*float32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field3) > 0 { + data6 := make([]byte, len(m.Field3)*10) + var j5 int + for _, num1 := range m.Field3 { + num := uint64(num1) + for num >= 1<<7 { + data6[j5] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j5++ + } + data6[j5] = uint8(num) + j5++ + } + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(j5)) + i += copy(data[i:], data6[:j5]) + } + if len(m.Field4) > 0 { + data8 := make([]byte, len(m.Field4)*10) + var j7 int + for _, num1 := range m.Field4 { + num := uint64(num1) + for num >= 1<<7 { + data8[j7] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j7++ + } + data8[j7] = uint8(num) + j7++ + } + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(j7)) + i += copy(data[i:], data8[:j7]) + } + if len(m.Field5) > 0 { + data10 := make([]byte, len(m.Field5)*10) + var j9 int + for _, num := range m.Field5 { + for num >= 1<<7 { + data10[j9] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j9++ + } + data10[j9] = uint8(num) + j9++ + } + data[i] = 0x2a + i++ + i = encodeVarintThetest(data, i, uint64(j9)) + i += copy(data[i:], data10[:j9]) + } + if len(m.Field6) > 0 { + data12 := make([]byte, len(m.Field6)*10) + var j11 int + for _, num := range m.Field6 { + for num >= 1<<7 { + data12[j11] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j11++ + } + data12[j11] = uint8(num) + j11++ + } + data[i] = 0x32 + i++ + i = encodeVarintThetest(data, i, uint64(j11)) + i += copy(data[i:], data12[:j11]) + } + if len(m.Field7) > 0 { + data13 := make([]byte, len(m.Field7)*5) + var j14 int + for _, num := range m.Field7 { + x15 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x15 >= 1<<7 { + data13[j14] = uint8(uint64(x15)&0x7f | 0x80) + j14++ + x15 >>= 7 + } + data13[j14] = uint8(x15) + j14++ + } + data[i] = 0x3a + i++ + i = encodeVarintThetest(data, i, uint64(j14)) + i += copy(data[i:], data13[:j14]) + } + if len(m.Field8) > 0 { + var j16 int + data18 := make([]byte, len(m.Field8)*10) + for _, num := range m.Field8 { + x17 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x17 >= 1<<7 { + data18[j16] = uint8(uint64(x17)&0x7f | 0x80) + j16++ + x17 >>= 7 + } + data18[j16] = uint8(x17) + j16++ + } + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(j16)) + i += copy(data[i:], data18[:j16]) + } + if len(m.Field9) > 0 { + data[i] = 0x4a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field9)*4)) + for _, num := range m.Field9 { + *(*uint32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field10) > 0 { + data[i] = 0x52 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field10)*4)) + for _, num := range m.Field10 { + *(*int32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field11) > 0 { + data[i] = 0x5a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field11)*8)) + for _, num := range m.Field11 { + *(*uint64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field12) > 0 { + data[i] = 0x62 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field12)*8)) + for _, num := range m.Field12 { + *(*int64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field13) > 0 { + data[i] = 0x6a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field13))) + for _, b := range m.Field13 { + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepPackedNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepPackedNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field1)*8)) + for _, num := range m.Field1 { + *(*float64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field2) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field2)*4)) + for _, num := range m.Field2 { + *(*float32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field3) > 0 { + data20 := make([]byte, len(m.Field3)*10) + var j19 int + for _, num1 := range m.Field3 { + num := uint64(num1) + for num >= 1<<7 { + data20[j19] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j19++ + } + data20[j19] = uint8(num) + j19++ + } + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(j19)) + i += copy(data[i:], data20[:j19]) + } + if len(m.Field4) > 0 { + data22 := make([]byte, len(m.Field4)*10) + var j21 int + for _, num1 := range m.Field4 { + num := uint64(num1) + for num >= 1<<7 { + data22[j21] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j21++ + } + data22[j21] = uint8(num) + j21++ + } + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(j21)) + i += copy(data[i:], data22[:j21]) + } + if len(m.Field5) > 0 { + data24 := make([]byte, len(m.Field5)*10) + var j23 int + for _, num := range m.Field5 { + for num >= 1<<7 { + data24[j23] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j23++ + } + data24[j23] = uint8(num) + j23++ + } + data[i] = 0x2a + i++ + i = encodeVarintThetest(data, i, uint64(j23)) + i += copy(data[i:], data24[:j23]) + } + if len(m.Field6) > 0 { + data26 := make([]byte, len(m.Field6)*10) + var j25 int + for _, num := range m.Field6 { + for num >= 1<<7 { + data26[j25] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j25++ + } + data26[j25] = uint8(num) + j25++ + } + data[i] = 0x32 + i++ + i = encodeVarintThetest(data, i, uint64(j25)) + i += copy(data[i:], data26[:j25]) + } + if len(m.Field7) > 0 { + data27 := make([]byte, len(m.Field7)*5) + var j28 int + for _, num := range m.Field7 { + x29 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x29 >= 1<<7 { + data27[j28] = uint8(uint64(x29)&0x7f | 0x80) + j28++ + x29 >>= 7 + } + data27[j28] = uint8(x29) + j28++ + } + data[i] = 0x3a + i++ + i = encodeVarintThetest(data, i, uint64(j28)) + i += copy(data[i:], data27[:j28]) + } + if len(m.Field8) > 0 { + var j30 int + data32 := make([]byte, len(m.Field8)*10) + for _, num := range m.Field8 { + x31 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x31 >= 1<<7 { + data32[j30] = uint8(uint64(x31)&0x7f | 0x80) + j30++ + x31 >>= 7 + } + data32[j30] = uint8(x31) + j30++ + } + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(j30)) + i += copy(data[i:], data32[:j30]) + } + if len(m.Field9) > 0 { + data[i] = 0x4a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field9)*4)) + for _, num := range m.Field9 { + *(*uint32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field10) > 0 { + data[i] = 0x52 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field10)*4)) + for _, num := range m.Field10 { + *(*int32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field11) > 0 { + data[i] = 0x5a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field11)*8)) + for _, num := range m.Field11 { + *(*uint64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field12) > 0 { + data[i] = 0x62 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field12)*8)) + for _, num := range m.Field12 { + *(*int64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field13) > 0 { + data[i] = 0x6a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field13))) + for _, b := range m.Field13 { + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidOptStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidOptStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = m.Field1 + i += 8 + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = m.Field2 + i += 4 + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3.Size())) + n33, err := m.Field3.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n33 + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field4.Size())) + n34, err := m.Field4.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n34 + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field6)) + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31)))) + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field8.Size())) + n35, err := m.Field8.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n35 + data[i] = 0x68 + i++ + if m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field14))) + i += copy(data[i:], m.Field14) + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = *m.Field1 + i += 8 + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = *m.Field2 + i += 4 + } + if m.Field3 != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3.Size())) + n36, err := m.Field3.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n36 + } + if m.Field4 != nil { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field4.Size())) + n37, err := m.Field4.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n37 + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field8 != nil { + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field8.Size())) + n38, err := m.Field8.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n38 + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field3) > 0 { + for _, msg := range m.Field3 { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field4) > 0 { + for _, msg := range m.Field4 { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field6) > 0 { + for _, num := range m.Field6 { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x38 + i++ + x39 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x39 >= 1<<7 { + data[i] = uint8(uint64(x39)&0x7f | 0x80) + x39 >>= 7 + i++ + } + data[i] = uint8(x39) + i++ + } + } + if len(m.Field8) > 0 { + for _, msg := range m.Field8 { + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field13) > 0 { + for _, b := range m.Field13 { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field3) > 0 { + for _, msg := range m.Field3 { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field4) > 0 { + for _, msg := range m.Field4 { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field6) > 0 { + for _, num := range m.Field6 { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x38 + i++ + x40 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x40 >= 1<<7 { + data[i] = uint8(uint64(x40)&0x7f | 0x80) + x40 >>= 7 + i++ + } + data[i] = uint8(x40) + i++ + } + } + if len(m.Field8) > 0 { + for _, msg := range m.Field8 { + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field13) > 0 { + for _, b := range m.Field13 { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidEmbeddedStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidEmbeddedStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NidOptNative != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.NidOptNative.Size())) + n41, err := m.NidOptNative.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n41 + } + data[i] = 0xc2 + i++ + data[i] = 0xc + i++ + i = encodeVarintThetest(data, i, uint64(m.Field200.Size())) + n42, err := m.Field200.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n42 + data[i] = 0x90 + i++ + data[i] = 0xd + i++ + if m.Field210 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinEmbeddedStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinEmbeddedStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NidOptNative != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.NidOptNative.Size())) + n43, err := m.NidOptNative.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n43 + } + if m.Field200 != nil { + data[i] = 0xc2 + i++ + data[i] = 0xc + i++ + i = encodeVarintThetest(data, i, uint64(m.Field200.Size())) + n44, err := m.Field200.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n44 + } + if m.Field210 != nil { + data[i] = 0x90 + i++ + data[i] = 0xd + i++ + if *m.Field210 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidNestedStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidNestedStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Field1.Size())) + n45, err := m.Field1.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n45 + if len(m.Field2) > 0 { + for _, msg := range m.Field2 { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinNestedStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinNestedStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Field1.Size())) + n46, err := m.Field1.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n46 + } + if len(m.Field2) > 0 { + for _, msg := range m.Field2 { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidOptCustom) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidOptCustom) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Id.Size())) + n47, err := m.Id.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n47 + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Value.Size())) + n48, err := m.Value.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n48 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomDash) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomDash) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Value != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Value.Size())) + n49, err := m.Value.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n49 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptCustom) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptCustom) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Id != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Id.Size())) + n50, err := m.Id.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n50 + } + if m.Value != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Value.Size())) + n51, err := m.Value.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n51 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepCustom) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepCustom) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Id) > 0 { + for _, msg := range m.Id { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Value) > 0 { + for _, msg := range m.Value { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepCustom) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepCustom) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Id) > 0 { + for _, msg := range m.Id { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Value) > 0 { + for _, msg := range m.Value { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptNativeUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptNativeUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = *m.Field1 + i += 8 + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = *m.Field2 + i += 4 + } + if m.Field3 != nil { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field3)) + } + if m.Field4 != nil { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field4)) + } + if m.Field5 != nil { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field5)) + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptStructUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptStructUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = *m.Field1 + i += 8 + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = *m.Field2 + i += 4 + } + if m.Field3 != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3.Size())) + n52, err := m.Field3.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n52 + } + if m.Field4 != nil { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field4.Size())) + n53, err := m.Field4.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n53 + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinEmbeddedStructUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinEmbeddedStructUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NidOptNative != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.NidOptNative.Size())) + n54, err := m.NidOptNative.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n54 + } + if m.Field200 != nil { + data[i] = 0xc2 + i++ + data[i] = 0xc + i++ + i = encodeVarintThetest(data, i, uint64(m.Field200.Size())) + n55, err := m.Field200.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n55 + } + if m.Field210 != nil { + data[i] = 0x90 + i++ + data[i] = 0xd + i++ + if *m.Field210 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinNestedStructUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinNestedStructUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Field1.Size())) + n56, err := m.Field1.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n56 + } + if m.Field2 != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field2.Size())) + n57, err := m.Field2.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n57 + } + if m.Field3 != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3.Size())) + n58, err := m.Field3.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n58 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Tree) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Tree) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Or != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Or.Size())) + n59, err := m.Or.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n59 + } + if m.And != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.And.Size())) + n60, err := m.And.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n60 + } + if m.Leaf != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Leaf.Size())) + n61, err := m.Leaf.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n61 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *OrBranch) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *OrBranch) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Left.Size())) + n62, err := m.Left.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n62 + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Right.Size())) + n63, err := m.Right.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n63 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AndBranch) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AndBranch) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Left.Size())) + n64, err := m.Left.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n64 + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Right.Size())) + n65, err := m.Right.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n65 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Leaf) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Leaf) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(m.Value)) + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.StrValue))) + i += copy(data[i:], m.StrValue) + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *DeepTree) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *DeepTree) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Down != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Down.Size())) + n66, err := m.Down.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n66 + } + if m.And != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.And.Size())) + n67, err := m.And.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n67 + } + if m.Leaf != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Leaf.Size())) + n68, err := m.Leaf.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n68 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *ADeepBranch) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *ADeepBranch) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Down.Size())) + n69, err := m.Down.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n69 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AndDeepBranch) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AndDeepBranch) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Left.Size())) + n70, err := m.Left.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n70 + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Right.Size())) + n71, err := m.Right.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n71 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *DeepLeaf) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *DeepLeaf) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Tree.Size())) + n72, err := m.Tree.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n72 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Nil) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Nil) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidOptEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidOptEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field1)) + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptEnumDefault) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptEnumDefault) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AnotherNinOptEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AnotherNinOptEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AnotherNinOptEnumDefault) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AnotherNinOptEnumDefault) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Timer) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Timer) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x9 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = m.Time1 + i += 8 + data[i] = 0x11 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = m.Time2 + i += 8 + if m.Data != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Data))) + i += copy(data[i:], m.Data) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *MyExtendable) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *MyExtendable) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if len(m.XXX_extensions) > 0 { + n, err := github_com_gogo_protobuf_proto.EncodeExtensionMap(m.XXX_extensions, data[i:]) + if err != nil { + return 0, err + } + i += n + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *OtherExtenable) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *OtherExtenable) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.M != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.M.Size())) + n73, err := m.M.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n73 + } + if m.Field2 != nil { + data[i] = 0x10 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field2)) + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field13)) + } + if len(m.XXX_extensions) > 0 { + n, err := github_com_gogo_protobuf_proto.EncodeExtensionMap(m.XXX_extensions, data[i:]) + if err != nil { + return 0, err + } + i += n + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NestedDefinition) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NestedDefinition) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.EnumField != nil { + data[i] = 0x10 + i++ + i = encodeVarintThetest(data, i, uint64(*m.EnumField)) + } + if m.NNM != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.NNM.Size())) + n74, err := m.NNM.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n74 + } + if m.NM != nil { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(m.NM.Size())) + n75, err := m.NM.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n75 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NestedDefinition_NestedMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NestedDefinition_NestedMessage) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NestedField1 != nil { + data[i] = 0x9 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = *m.NestedField1 + i += 8 + } + if m.NNM != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.NNM.Size())) + n76, err := m.NNM.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n76 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NestedNestedField1 != nil { + data[i] = 0x52 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.NestedNestedField1))) + i += copy(data[i:], *m.NestedNestedField1) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NestedScope) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NestedScope) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.A != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.A.Size())) + n77, err := m.A.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n77 + } + if m.B != nil { + data[i] = 0x10 + i++ + i = encodeVarintThetest(data, i, uint64(*m.B)) + } + if m.C != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.C.Size())) + n78, err := m.C.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n78 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptNativeDefault) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptNativeDefault) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = *m.Field1 + i += 8 + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = *m.Field2 + i += 4 + } + if m.Field3 != nil { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field3)) + } + if m.Field4 != nil { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field4)) + } + if m.Field5 != nil { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field5)) + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field8 != nil { + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(*m.Field8)<<1)^uint64((*m.Field8>>63)))) + } + if m.Field9 != nil { + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = *m.Field9 + i += 4 + } + if m.Field10 != nil { + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = *m.Field10 + i += 4 + } + if m.Field11 != nil { + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = *m.Field11 + i += 8 + } + if m.Field12 != nil { + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = *m.Field12 + i += 8 + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomContainer) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomContainer) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.CustomStruct.Size())) + n79, err := m.CustomStruct.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n79 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNidOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNidOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = m.FieldA + i += 8 + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = m.FieldB + i += 4 + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldC)) + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldD)) + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldE)) + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldF)) + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(m.FieldG)<<1)^uint32((m.FieldG>>31)))) + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(m.FieldH)<<1)^uint64((m.FieldH>>63)))) + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = m.FieldI + i += 4 + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = m.FieldJ + i += 4 + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = m.FieldK + i += 8 + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = m.FieldL + i += 8 + data[i] = 0x68 + i++ + if m.FieldM { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.FieldN))) + i += copy(data[i:], m.FieldN) + if m.FieldO != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.FieldO))) + i += copy(data[i:], m.FieldO) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNinOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNinOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.FieldA != nil { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = *m.FieldA + i += 8 + } + if m.FieldB != nil { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = *m.FieldB + i += 4 + } + if m.FieldC != nil { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldC)) + } + if m.FieldD != nil { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldD)) + } + if m.FieldE != nil { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldE)) + } + if m.FieldF != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldF)) + } + if m.FieldG != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.FieldG)<<1)^uint32((*m.FieldG>>31)))) + } + if m.FieldH != nil { + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(*m.FieldH)<<1)^uint64((*m.FieldH>>63)))) + } + if m.FieldI != nil { + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = *m.FieldI + i += 4 + } + if m.FieldJ != nil { + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = *m.FieldJ + i += 4 + } + if m.FieldK != nil { + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = *m.FieldK + i += 8 + } + if m.FielL != nil { + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = *m.FielL + i += 8 + } + if m.FieldM != nil { + data[i] = 0x68 + i++ + if *m.FieldM { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.FieldN != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.FieldN))) + i += copy(data[i:], *m.FieldN) + } + if m.FieldO != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.FieldO))) + i += copy(data[i:], m.FieldO) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNinRepNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNinRepNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.FieldA) > 0 { + for _, num := range m.FieldA { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.FieldB) > 0 { + for _, num := range m.FieldB { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.FieldC) > 0 { + for _, num := range m.FieldC { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.FieldD) > 0 { + for _, num := range m.FieldD { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.FieldE) > 0 { + for _, num := range m.FieldE { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.FieldF) > 0 { + for _, num := range m.FieldF { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.FieldG) > 0 { + for _, num := range m.FieldG { + data[i] = 0x38 + i++ + x80 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x80 >= 1<<7 { + data[i] = uint8(uint64(x80)&0x7f | 0x80) + x80 >>= 7 + i++ + } + data[i] = uint8(x80) + i++ + } + } + if len(m.FieldH) > 0 { + for _, num := range m.FieldH { + data[i] = 0x40 + i++ + x81 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x81 >= 1<<7 { + data[i] = uint8(uint64(x81)&0x7f | 0x80) + x81 >>= 7 + i++ + } + data[i] = uint8(x81) + i++ + } + } + if len(m.FieldI) > 0 { + for _, num := range m.FieldI { + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.FieldJ) > 0 { + for _, num := range m.FieldJ { + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.FieldK) > 0 { + for _, num := range m.FieldK { + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.FieldL) > 0 { + for _, num := range m.FieldL { + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.FieldM) > 0 { + for _, b := range m.FieldM { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.FieldN) > 0 { + for _, s := range m.FieldN { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.FieldO) > 0 { + for _, b := range m.FieldO { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNinStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNinStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.FieldA != nil { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = *m.FieldA + i += 8 + } + if m.FieldB != nil { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = *m.FieldB + i += 4 + } + if m.FieldC != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldC.Size())) + n82, err := m.FieldC.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n82 + } + if len(m.FieldD) > 0 { + for _, msg := range m.FieldD { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.FieldE != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldE)) + } + if m.FieldF != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.FieldF)<<1)^uint32((*m.FieldF>>31)))) + } + if m.FieldG != nil { + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldG.Size())) + n83, err := m.FieldG.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n83 + } + if m.FieldH != nil { + data[i] = 0x68 + i++ + if *m.FieldH { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.FieldI != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.FieldI))) + i += copy(data[i:], *m.FieldI) + } + if m.FieldJ != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.FieldJ))) + i += copy(data[i:], m.FieldJ) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameCustomType) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameCustomType) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.FieldA != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldA.Size())) + n84, err := m.FieldA.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n84 + } + if m.FieldB != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldB.Size())) + n85, err := m.FieldB.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n85 + } + if len(m.FieldC) > 0 { + for _, msg := range m.FieldC { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.FieldD) > 0 { + for _, msg := range m.FieldD { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNinEmbeddedStructUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNinEmbeddedStructUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NidOptNative != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.NidOptNative.Size())) + n86, err := m.NidOptNative.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n86 + } + if m.FieldA != nil { + data[i] = 0xc2 + i++ + data[i] = 0xc + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldA.Size())) + n87, err := m.FieldA.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n87 + } + if m.FieldB != nil { + data[i] = 0x90 + i++ + data[i] = 0xd + i++ + if *m.FieldB { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.FieldA != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldA)) + } + if len(m.FieldB) > 0 { + for _, num := range m.FieldB { + data[i] = 0x10 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NoExtensionsMap) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NoExtensionsMap) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + i += copy(data[i:], m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Unrecognized) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Unrecognized) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field1))) + i += copy(data[i:], *m.Field1) + } + return i, nil +} + +func (m *UnrecognizedWithInner) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnrecognizedWithInner) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Embedded) > 0 { + for _, msg := range m.Embedded { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.Field2 != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field2))) + i += copy(data[i:], *m.Field2) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *UnrecognizedWithInner_Inner) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnrecognizedWithInner_Inner) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + return i, nil +} + +func (m *UnrecognizedWithEmbed) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnrecognizedWithEmbed) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.UnrecognizedWithEmbed_Embedded.Size())) + n88, err := m.UnrecognizedWithEmbed_Embedded.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n88 + if m.Field2 != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field2))) + i += copy(data[i:], *m.Field2) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *UnrecognizedWithEmbed_Embedded) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnrecognizedWithEmbed_Embedded) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + return i, nil +} + +func encodeFixed64Thetest(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Thetest(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintThetest(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *NidOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.Field1 = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + m.Field2 = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + m.Field3 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field3 |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + m.Field4 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field4 |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + m.Field5 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field5 |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + m.Field6 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field6 |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = int64(v) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + m.Field9 = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + m.Field10 = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.Field11 = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.Field12 = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = bool(v != 0) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = &v + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = &v + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = &v + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + v2 := int64(v) + m.Field8 = &v2 + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = &v + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = &v + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = &v + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = append(m.Field9, v) + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = append(m.Field10, v) + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = append(m.Field11, v) + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = append(m.Field12, v) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = append(m.Field14, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx)) + copy(m.Field15[len(m.Field15)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = append(m.Field9, v) + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = append(m.Field10, v) + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = append(m.Field11, v) + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = append(m.Field12, v) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = append(m.Field14, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx)) + copy(m.Field15[len(m.Field15)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepPackedNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepPackedNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepPackedNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + } + } else if wireType == 1 { + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + case 2: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + } + } else if wireType == 5 { + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + case 3: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + case 4: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } + } else if wireType == 0 { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + case 5: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } + } else if wireType == 0 { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + case 6: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + case 7: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + case 8: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + case 9: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = append(m.Field9, v) + } + } else if wireType == 5 { + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = append(m.Field9, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + case 10: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = append(m.Field10, v) + } + } else if wireType == 5 { + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = append(m.Field10, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + case 11: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = append(m.Field11, v) + } + } else if wireType == 1 { + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = append(m.Field11, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + case 12: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = append(m.Field12, v) + } + } else if wireType == 1 { + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = append(m.Field12, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + case 13: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } + } else if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepPackedNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepPackedNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepPackedNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + } + } else if wireType == 1 { + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + case 2: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + } + } else if wireType == 5 { + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + case 3: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + case 4: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } + } else if wireType == 0 { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + case 5: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } + } else if wireType == 0 { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + case 6: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + case 7: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + case 8: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + case 9: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = append(m.Field9, v) + } + } else if wireType == 5 { + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = append(m.Field9, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + case 10: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = append(m.Field10, v) + } + } else if wireType == 5 { + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = append(m.Field10, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + case 11: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = append(m.Field11, v) + } + } else if wireType == 1 { + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = append(m.Field11, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + case 12: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = append(m.Field12, v) + } + } else if wireType == 1 { + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = append(m.Field12, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + case 13: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } + } else if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidOptStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidOptStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidOptStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.Field1 = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + m.Field2 = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field4.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + m.Field6 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field6 |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = v + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field8.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = bool(v != 0) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = &v + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = &v + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field3 == nil { + m.Field3 = &NidOptNative{} + } + if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field4 == nil { + m.Field4 = &NinOptNative{} + } + if err := m.Field4.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field8 == nil { + m.Field8 = &NidOptNative{} + } + if err := m.Field8.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field3 = append(m.Field3, NidOptNative{}) + if err := m.Field3[len(m.Field3)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field4 = append(m.Field4, NinOptNative{}) + if err := m.Field4[len(m.Field4)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field8 = append(m.Field8, NidOptNative{}) + if err := m.Field8[len(m.Field8)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = append(m.Field14, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx)) + copy(m.Field15[len(m.Field15)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field3 = append(m.Field3, &NidOptNative{}) + if err := m.Field3[len(m.Field3)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field4 = append(m.Field4, &NinOptNative{}) + if err := m.Field4[len(m.Field4)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field8 = append(m.Field8, &NidOptNative{}) + if err := m.Field8[len(m.Field8)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = append(m.Field14, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx)) + copy(m.Field15[len(m.Field15)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidEmbeddedStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidEmbeddedStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidEmbeddedStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NidOptNative == nil { + m.NidOptNative = &NidOptNative{} + } + if err := m.NidOptNative.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field200", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field200.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 210: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field210", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field210 = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinEmbeddedStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinEmbeddedStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinEmbeddedStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NidOptNative == nil { + m.NidOptNative = &NidOptNative{} + } + if err := m.NidOptNative.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field200", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field200 == nil { + m.Field200 = &NidOptNative{} + } + if err := m.Field200.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 210: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field210", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field210 = &b + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidNestedStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidNestedStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidNestedStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field1.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field2 = append(m.Field2, NidRepStruct{}) + if err := m.Field2[len(m.Field2)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinNestedStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinNestedStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinNestedStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field1 == nil { + m.Field1 = &NinOptStruct{} + } + if err := m.Field1.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field2 = append(m.Field2, &NinRepStruct{}) + if err := m.Field2[len(m.Field2)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidOptCustom) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidOptCustom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidOptCustom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Id.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Value.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomDash) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomDash: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomDash: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom_dash_type.Bytes + m.Value = &v + if err := m.Value.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptCustom) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptCustom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptCustom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.Id = &v + if err := m.Id.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.Value = &v + if err := m.Value.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepCustom) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepCustom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepCustom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.Id = append(m.Id, v) + if err := m.Id[len(m.Id)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.Value = append(m.Value, v) + if err := m.Value[len(m.Value)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepCustom) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepCustom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepCustom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.Id = append(m.Id, v) + if err := m.Id[len(m.Id)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.Value = append(m.Value, v) + if err := m.Value[len(m.Value)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptNativeUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptNativeUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptNativeUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = &v + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = &v + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = &v + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptStructUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptStructUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptStructUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = &v + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = &v + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field3 == nil { + m.Field3 = &NidOptNative{} + } + if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field4 == nil { + m.Field4 = &NinOptNative{} + } + if err := m.Field4.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinEmbeddedStructUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinEmbeddedStructUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinEmbeddedStructUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NidOptNative == nil { + m.NidOptNative = &NidOptNative{} + } + if err := m.NidOptNative.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field200", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field200 == nil { + m.Field200 = &NinOptNative{} + } + if err := m.Field200.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 210: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field210", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field210 = &b + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinNestedStructUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinNestedStructUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinNestedStructUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field1 == nil { + m.Field1 = &NinOptNativeUnion{} + } + if err := m.Field1.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field2 == nil { + m.Field2 = &NinOptStructUnion{} + } + if err := m.Field2.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field3 == nil { + m.Field3 = &NinEmbeddedStructUnion{} + } + if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Tree) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Tree: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Tree: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Or", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Or == nil { + m.Or = &OrBranch{} + } + if err := m.Or.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field And", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.And == nil { + m.And = &AndBranch{} + } + if err := m.And.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Leaf", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Leaf == nil { + m.Leaf = &Leaf{} + } + if err := m.Leaf.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OrBranch) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OrBranch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OrBranch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Left.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Right.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AndBranch) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AndBranch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AndBranch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Left.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Right.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Leaf) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Leaf: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Leaf: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + m.Value = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Value |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StrValue", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StrValue = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DeepTree) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DeepTree: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeepTree: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Down", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Down == nil { + m.Down = &ADeepBranch{} + } + if err := m.Down.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field And", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.And == nil { + m.And = &AndDeepBranch{} + } + if err := m.And.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Leaf", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Leaf == nil { + m.Leaf = &DeepLeaf{} + } + if err := m.Leaf.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ADeepBranch) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ADeepBranch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ADeepBranch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Down", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Down.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AndDeepBranch) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AndDeepBranch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AndDeepBranch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Left.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Right.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DeepLeaf) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DeepLeaf: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeepLeaf: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tree", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Tree.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Nil) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Nil: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Nil: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidOptEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidOptEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidOptEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + m.Field1 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field1 |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = append(m.Field1, v) + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = append(m.Field1, v) + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptEnumDefault) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptEnumDefault: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptEnumDefault: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnotherNinOptEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnotherNinOptEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnotherNinOptEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v AnotherTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (AnotherTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnotherNinOptEnumDefault) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnotherNinOptEnumDefault: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnotherNinOptEnumDefault: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v AnotherTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (AnotherTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Timer) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Timer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Timer: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Time1", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.Time1 = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 2: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Time2", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.Time2 = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MyExtendable) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MyExtendable: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MyExtendable: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + if (fieldNum >= 100) && (fieldNum < 200) { + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + iNdEx -= sizeOfWire + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]github_com_gogo_protobuf_proto.Extension) + } + m.XXX_extensions[int32(fieldNum)] = github_com_gogo_protobuf_proto.NewExtension(data[iNdEx : iNdEx+skippy]) + iNdEx += skippy + } else { + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OtherExtenable) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OtherExtenable: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OtherExtenable: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field M", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.M == nil { + m.M = &MyExtendable{} + } + if err := m.M.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field2 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = &v + default: + if ((fieldNum >= 14) && (fieldNum < 17)) || ((fieldNum >= 10) && (fieldNum < 13)) { + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + iNdEx -= sizeOfWire + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]github_com_gogo_protobuf_proto.Extension) + } + m.XXX_extensions[int32(fieldNum)] = github_com_gogo_protobuf_proto.NewExtension(data[iNdEx : iNdEx+skippy]) + iNdEx += skippy + } else { + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NestedDefinition) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NestedDefinition: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NestedDefinition: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EnumField", wireType) + } + var v NestedDefinition_NestedEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (NestedDefinition_NestedEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.EnumField = &v + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NNM", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NNM == nil { + m.NNM = &NestedDefinition_NestedMessage_NestedNestedMsg{} + } + if err := m.NNM.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NM", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NM == nil { + m.NM = &NestedDefinition_NestedMessage{} + } + if err := m.NM.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NestedDefinition_NestedMessage) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NestedMessage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NestedMessage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field NestedField1", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.NestedField1 = &v + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NNM", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NNM == nil { + m.NNM = &NestedDefinition_NestedMessage_NestedNestedMsg{} + } + if err := m.NNM.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NestedNestedMsg: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NestedNestedMsg: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NestedNestedField1", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.NestedNestedField1 = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NestedScope) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NestedScope: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NestedScope: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.A == nil { + m.A = &NestedDefinition_NestedMessage_NestedNestedMsg{} + } + if err := m.A.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var v NestedDefinition_NestedEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (NestedDefinition_NestedEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.B = &v + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field C", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.C == nil { + m.C = &NestedDefinition_NestedMessage{} + } + if err := m.C.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptNativeDefault) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptNativeDefault: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptNativeDefault: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = &v + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = &v + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = &v + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + v2 := int64(v) + m.Field8 = &v2 + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = &v + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = &v + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = &v + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomContainer) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomContainer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomContainer: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CustomStruct", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.CustomStruct.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNidOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNidOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNidOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.FieldA = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + m.FieldB = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + m.FieldC = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.FieldC |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + m.FieldD = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.FieldD |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) + } + m.FieldE = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.FieldE |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) + } + m.FieldF = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.FieldF |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.FieldG = v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.FieldH = int64(v) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType) + } + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + m.FieldI = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType) + } + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + m.FieldJ = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldK", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.FieldK = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldL", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.FieldL = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldM", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldM = bool(v != 0) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldN", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldN = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldO", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldO = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNinOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNinOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNinOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.FieldA = &v + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.FieldB = &v + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldC = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldD = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldE = &v + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldF = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.FieldG = &v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + v2 := int64(v) + m.FieldH = &v2 + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType) + } + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.FieldI = &v + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType) + } + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.FieldJ = &v + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldK", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.FieldK = &v + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FielL", wireType) + } + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.FielL = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldM", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.FieldM = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldN", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.FieldN = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldO", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldO = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNinRepNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNinRepNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNinRepNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.FieldA = append(m.FieldA, v) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.FieldB = append(m.FieldB, v) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldC = append(m.FieldC, v) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldD = append(m.FieldD, v) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldE = append(m.FieldE, v) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldF = append(m.FieldF, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.FieldG = append(m.FieldG, v) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.FieldH = append(m.FieldH, int64(v)) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType) + } + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.FieldI = append(m.FieldI, v) + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType) + } + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.FieldJ = append(m.FieldJ, v) + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldK", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.FieldK = append(m.FieldK, v) + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldL", wireType) + } + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.FieldL = append(m.FieldL, v) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldM", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldM = append(m.FieldM, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldN", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldN = append(m.FieldN, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldO", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldO = append(m.FieldO, make([]byte, postIndex-iNdEx)) + copy(m.FieldO[len(m.FieldO)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNinStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNinStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNinStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.FieldA = &v + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.FieldB = &v + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FieldC == nil { + m.FieldC = &NidOptNative{} + } + if err := m.FieldC.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldD = append(m.FieldD, &NinOptNative{}) + if err := m.FieldD[len(m.FieldD)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldE = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.FieldF = &v + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FieldG == nil { + m.FieldG = &NidOptNative{} + } + if err := m.FieldG.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.FieldH = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.FieldI = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldJ = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameCustomType) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameCustomType: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameCustomType: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.FieldA = &v + if err := m.FieldA.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.FieldB = &v + if err := m.FieldB.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.FieldC = append(m.FieldC, v) + if err := m.FieldC[len(m.FieldC)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.FieldD = append(m.FieldD, v) + if err := m.FieldD[len(m.FieldD)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNinEmbeddedStructUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNinEmbeddedStructUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNinEmbeddedStructUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NidOptNative == nil { + m.NidOptNative = &NidOptNative{} + } + if err := m.NidOptNative.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FieldA == nil { + m.FieldA = &NinOptNative{} + } + if err := m.FieldA.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 210: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.FieldB = &b + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldA = &v + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldB = append(m.FieldB, v) + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NoExtensionsMap) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NoExtensionsMap: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NoExtensionsMap: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + if (fieldNum >= 100) && (fieldNum < 200) { + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + iNdEx -= sizeOfWire + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_extensions = append(m.XXX_extensions, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } else { + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Unrecognized) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Unrecognized: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Unrecognized: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field1 = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnrecognizedWithInner) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UnrecognizedWithInner: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UnrecognizedWithInner: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Embedded", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Embedded = append(m.Embedded, &UnrecognizedWithInner_Inner{}) + if err := m.Embedded[len(m.Embedded)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field2 = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnrecognizedWithInner_Inner) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Inner: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Inner: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnrecognizedWithEmbed) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UnrecognizedWithEmbed: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UnrecognizedWithEmbed: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnrecognizedWithEmbed_Embedded", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.UnrecognizedWithEmbed_Embedded.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field2 = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnrecognizedWithEmbed_Embedded) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Embedded: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Embedded: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipThetestUnsafe(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthThetestUnsafe + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipThetestUnsafe(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthThetestUnsafe = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowThetestUnsafe = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeboth/thetest.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeboth/thetest.proto new file mode 100644 index 0000000000000000000000000000000000000000..175ec64d0a2f360883396ec14a53e4957b2afae6 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeboth/thetest.proto @@ -0,0 +1,584 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package test; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = true; +option (gogoproto.unsafe_unmarshaler_all) = true; + +message NidOptNative { + optional double Field1 = 1 [(gogoproto.nullable) = false]; + optional float Field2 = 2 [(gogoproto.nullable) = false]; + optional int32 Field3 = 3 [(gogoproto.nullable) = false]; + optional int64 Field4 = 4 [(gogoproto.nullable) = false]; + optional uint32 Field5 = 5 [(gogoproto.nullable) = false]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false]; + optional sint64 Field8 = 8 [(gogoproto.nullable) = false]; + optional fixed32 Field9 = 9 [(gogoproto.nullable) = false]; + optional sfixed32 Field10 = 10 [(gogoproto.nullable) = false]; + optional fixed64 Field11 = 11 [(gogoproto.nullable) = false]; + optional sfixed64 Field12 = 12 [(gogoproto.nullable) = false]; + optional bool Field13 = 13 [(gogoproto.nullable) = false]; + optional string Field14 = 14 [(gogoproto.nullable) = false]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinOptNative { + optional double Field1 = 1; + optional float Field2 = 2; + optional int32 Field3 = 3; + optional int64 Field4 = 4; + optional uint32 Field5 = 5; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional sint64 Field8 = 8; + optional fixed32 Field9 = 9; + optional sfixed32 Field10 = 10; + optional fixed64 Field11 = 11; + optional sfixed64 Field12 = 12; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NidRepNative { + repeated double Field1 = 1 [(gogoproto.nullable) = false]; + repeated float Field2 = 2 [(gogoproto.nullable) = false]; + repeated int32 Field3 = 3 [(gogoproto.nullable) = false]; + repeated int64 Field4 = 4 [(gogoproto.nullable) = false]; + repeated uint32 Field5 = 5 [(gogoproto.nullable) = false]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false]; + repeated sint64 Field8 = 8 [(gogoproto.nullable) = false]; + repeated fixed32 Field9 = 9 [(gogoproto.nullable) = false]; + repeated sfixed32 Field10 = 10 [(gogoproto.nullable) = false]; + repeated fixed64 Field11 = 11 [(gogoproto.nullable) = false]; + repeated sfixed64 Field12 = 12 [(gogoproto.nullable) = false]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false]; + repeated string Field14 = 14 [(gogoproto.nullable) = false]; + repeated bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinRepNative { + repeated double Field1 = 1; + repeated float Field2 = 2; + repeated int32 Field3 = 3; + repeated int64 Field4 = 4; + repeated uint32 Field5 = 5; + repeated uint64 Field6 = 6; + repeated sint32 Field7 = 7; + repeated sint64 Field8 = 8; + repeated fixed32 Field9 = 9; + repeated sfixed32 Field10 = 10; + repeated fixed64 Field11 = 11; + repeated sfixed64 Field12 = 12; + repeated bool Field13 = 13; + repeated string Field14 = 14; + repeated bytes Field15 = 15; +} + +message NidRepPackedNative { + repeated double Field1 = 1 [(gogoproto.nullable) = false, packed = true]; + repeated float Field2 = 2 [(gogoproto.nullable) = false, packed = true]; + repeated int32 Field3 = 3 [(gogoproto.nullable) = false, packed = true]; + repeated int64 Field4 = 4 [(gogoproto.nullable) = false, packed = true]; + repeated uint32 Field5 = 5 [(gogoproto.nullable) = false, packed = true]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false, packed = true]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false, packed = true]; + repeated sint64 Field8 = 8 [(gogoproto.nullable) = false, packed = true]; + repeated fixed32 Field9 = 9 [(gogoproto.nullable) = false, packed = true]; + repeated sfixed32 Field10 = 10 [(gogoproto.nullable) = false, packed = true]; + repeated fixed64 Field11 = 11 [(gogoproto.nullable) = false, packed = true]; + repeated sfixed64 Field12 = 12 [(gogoproto.nullable) = false, packed = true]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false, packed = true]; +} + +message NinRepPackedNative { + repeated double Field1 = 1 [packed = true]; + repeated float Field2 = 2 [packed = true]; + repeated int32 Field3 = 3 [packed = true]; + repeated int64 Field4 = 4 [packed = true]; + repeated uint32 Field5 = 5 [packed = true]; + repeated uint64 Field6 = 6 [packed = true]; + repeated sint32 Field7 = 7 [packed = true]; + repeated sint64 Field8 = 8 [packed = true]; + repeated fixed32 Field9 = 9 [packed = true]; + repeated sfixed32 Field10 = 10 [packed = true]; + repeated fixed64 Field11 = 11 [packed = true]; + repeated sfixed64 Field12 = 12 [packed = true]; + repeated bool Field13 = 13 [packed = true]; +} + +message NidOptStruct { + optional double Field1 = 1 [(gogoproto.nullable) = false]; + optional float Field2 = 2 [(gogoproto.nullable) = false]; + optional NidOptNative Field3 = 3 [(gogoproto.nullable) = false]; + optional NinOptNative Field4 = 4 [(gogoproto.nullable) = false]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false]; + optional NidOptNative Field8 = 8 [(gogoproto.nullable) = false]; + optional bool Field13 = 13 [(gogoproto.nullable) = false]; + optional string Field14 = 14 [(gogoproto.nullable) = false]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinOptStruct { + optional double Field1 = 1; + optional float Field2 = 2; + optional NidOptNative Field3 = 3; + optional NinOptNative Field4 = 4; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional NidOptNative Field8 = 8; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NidRepStruct { + repeated double Field1 = 1 [(gogoproto.nullable) = false]; + repeated float Field2 = 2 [(gogoproto.nullable) = false]; + repeated NidOptNative Field3 = 3 [(gogoproto.nullable) = false]; + repeated NinOptNative Field4 = 4 [(gogoproto.nullable) = false]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false]; + repeated NidOptNative Field8 = 8 [(gogoproto.nullable) = false]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false]; + repeated string Field14 = 14 [(gogoproto.nullable) = false]; + repeated bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinRepStruct { + repeated double Field1 = 1; + repeated float Field2 = 2; + repeated NidOptNative Field3 = 3; + repeated NinOptNative Field4 = 4; + repeated uint64 Field6 = 6; + repeated sint32 Field7 = 7; + repeated NidOptNative Field8 = 8; + repeated bool Field13 = 13; + repeated string Field14 = 14; + repeated bytes Field15 = 15; +} + +message NidEmbeddedStruct { + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NidOptNative Field200 = 200 [(gogoproto.nullable) = false]; + optional bool Field210 = 210 [(gogoproto.nullable) = false]; +} + +message NinEmbeddedStruct { + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NidOptNative Field200 = 200; + optional bool Field210 = 210; +} + +message NidNestedStruct { + optional NidOptStruct Field1 = 1 [(gogoproto.nullable) = false]; + repeated NidRepStruct Field2 = 2 [(gogoproto.nullable) = false]; +} + +message NinNestedStruct { + optional NinOptStruct Field1 = 1; + repeated NinRepStruct Field2 = 2; +} + +message NidOptCustom { + optional bytes Id = 1 [(gogoproto.customtype) = "Uuid", (gogoproto.nullable) = false]; + optional bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; +} + +message CustomDash { + optional bytes Value = 1 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom-dash-type.Bytes"]; +} + +message NinOptCustom { + optional bytes Id = 1 [(gogoproto.customtype) = "Uuid"]; + optional bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message NidRepCustom { + repeated bytes Id = 1 [(gogoproto.customtype) = "Uuid", (gogoproto.nullable) = false]; + repeated bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; +} + +message NinRepCustom { + repeated bytes Id = 1 [(gogoproto.customtype) = "Uuid"]; + repeated bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message NinOptNativeUnion { + option (gogoproto.onlyone) = true; + optional double Field1 = 1; + optional float Field2 = 2; + optional int32 Field3 = 3; + optional int64 Field4 = 4; + optional uint32 Field5 = 5; + optional uint64 Field6 = 6; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NinOptStructUnion { + option (gogoproto.onlyone) = true; + optional double Field1 = 1; + optional float Field2 = 2; + optional NidOptNative Field3 = 3; + optional NinOptNative Field4 = 4; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NinEmbeddedStructUnion { + option (gogoproto.onlyone) = true; + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NinOptNative Field200 = 200; + optional bool Field210 = 210; +} + +message NinNestedStructUnion { + option (gogoproto.onlyone) = true; + optional NinOptNativeUnion Field1 = 1; + optional NinOptStructUnion Field2 = 2; + optional NinEmbeddedStructUnion Field3 = 3; +} + +message Tree { + option (gogoproto.onlyone) = true; + optional OrBranch Or = 1; + optional AndBranch And = 2; + optional Leaf Leaf = 3; +} + +message OrBranch { + optional Tree Left = 1 [(gogoproto.nullable) = false]; + optional Tree Right = 2 [(gogoproto.nullable) = false]; +} + +message AndBranch { + optional Tree Left = 1 [(gogoproto.nullable) = false]; + optional Tree Right = 2 [(gogoproto.nullable) = false]; +} + +message Leaf { + optional int64 Value = 1 [(gogoproto.nullable) = false]; + optional string StrValue = 2 [(gogoproto.nullable) = false]; +} + +message DeepTree { + option (gogoproto.onlyone) = true; + optional ADeepBranch Down = 1; + optional AndDeepBranch And = 2; + optional DeepLeaf Leaf = 3; +} + +message ADeepBranch { + optional DeepTree Down = 2 [(gogoproto.nullable) = false]; +} + +message AndDeepBranch { + optional DeepTree Left = 1 [(gogoproto.nullable) = false]; + optional DeepTree Right = 2 [(gogoproto.nullable) = false]; +} + +message DeepLeaf { + optional Tree Tree = 1 [(gogoproto.nullable) = false]; +} + +message Nil { + +} + +enum TheTestEnum { + A = 0; + B = 1; + C = 2; +} + +message NidOptEnum { + optional TheTestEnum Field1 = 1 [(gogoproto.nullable) = false]; +} + +message NinOptEnum { + optional TheTestEnum Field1 = 1; +} + +message NidRepEnum { + repeated TheTestEnum Field1 = 1 [(gogoproto.nullable) = false]; +} + +message NinRepEnum { + repeated TheTestEnum Field1 = 1; +} + +message NinOptEnumDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional TheTestEnum Field1 = 1 [default=C]; +} + +enum AnotherTestEnum { + option (gogoproto.goproto_enum_prefix) = false; + D = 10; + E = 11; +} + +message AnotherNinOptEnum { + optional AnotherTestEnum Field1 = 1; +} + +message AnotherNinOptEnumDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional AnotherTestEnum Field1 = 1 [default=E]; +} + +message Timer { + optional sfixed64 Time1 = 1 [(gogoproto.nullable) = false]; + optional sfixed64 Time2 = 2 [(gogoproto.nullable) = false]; + optional bytes Data = 3 [(gogoproto.nullable) = false]; +} + +message MyExtendable { + option (gogoproto.face) = false; + optional int64 Field1 = 1; + extensions 100 to 199; +} + +extend MyExtendable { + optional double FieldA = 100; + optional NinOptNative FieldB = 101; + optional NinEmbeddedStruct FieldC = 102; +} + +message OtherExtenable { + option (gogoproto.face) = false; + optional int64 Field2 = 2; + extensions 14 to 16; + optional int64 Field13 = 13; + extensions 10 to 12; + optional MyExtendable M = 1; +} + +message NestedDefinition { + optional int64 Field1 = 1; + message NestedMessage { + optional fixed64 NestedField1 = 1; + optional NestedNestedMsg NNM = 2; + message NestedNestedMsg { + optional string NestedNestedField1 = 10; + } + } + enum NestedEnum { + TYPE_NESTED = 1; + } + optional NestedEnum EnumField = 2; + optional NestedMessage.NestedNestedMsg NNM = 3; + optional NestedMessage NM = 4; +} + +message NestedScope { + optional NestedDefinition.NestedMessage.NestedNestedMsg A = 1; + optional NestedDefinition.NestedEnum B = 2; + optional NestedDefinition.NestedMessage C = 3; +} + +message NinOptNativeDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional double Field1 = 1 [default = 1234.1234]; + optional float Field2 = 2 [default = 1234.1234]; + optional int32 Field3 = 3 [default = 1234]; + optional int64 Field4 = 4 [default = 1234]; + optional uint32 Field5 = 5 [default = 1234]; + optional uint64 Field6 = 6 [default = 1234]; + optional sint32 Field7 = 7 [default = 1234]; + optional sint64 Field8 = 8 [default = 1234]; + optional fixed32 Field9 = 9 [default = 1234]; + optional sfixed32 Field10 = 10 [default = 1234]; + optional fixed64 Field11 = 11 [default = 1234]; + optional sfixed64 Field12 = 12 [default = 1234]; + optional bool Field13 = 13 [default = true]; + optional string Field14 = 14 [default = "1234"]; + optional bytes Field15 = 15; +} + +message CustomContainer { + optional NidOptCustom CustomStruct = 1 [(gogoproto.nullable) = false]; +} + +message CustomNameNidOptNative { + optional double Field1 = 1 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldB"]; + optional int32 Field3 = 3 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldC"]; + optional int64 Field4 = 4 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldD"]; + optional uint32 Field5 = 5 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldE"]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldF"]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldG"]; + optional sint64 Field8 = 8 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldH"]; + optional fixed32 Field9 = 9 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldI"]; + optional sfixed32 Field10 = 10 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldJ"]; + optional fixed64 Field11 = 11 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldK"]; + optional sfixed64 Field12 = 12 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldL"]; + optional bool Field13 = 13 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldM"]; + optional string Field14 = 14 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldN"]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinOptNative { + optional double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + optional int32 Field3 = 3 [(gogoproto.customname) = "FieldC"]; + optional int64 Field4 = 4 [(gogoproto.customname) = "FieldD"]; + optional uint32 Field5 = 5 [(gogoproto.customname) = "FieldE"]; + optional uint64 Field6 = 6 [(gogoproto.customname) = "FieldF"]; + optional sint32 Field7 = 7 [(gogoproto.customname) = "FieldG"]; + optional sint64 Field8 = 8 [(gogoproto.customname) = "FieldH"]; + optional fixed32 Field9 = 9 [(gogoproto.customname) = "FieldI"]; + optional sfixed32 Field10 = 10 [(gogoproto.customname) = "FieldJ"]; + optional fixed64 Field11 = 11 [(gogoproto.customname) = "FieldK"]; + optional sfixed64 Field12 = 12 [(gogoproto.customname) = "FielL"]; + optional bool Field13 = 13 [(gogoproto.customname) = "FieldM"]; + optional string Field14 = 14 [(gogoproto.customname) = "FieldN"]; + optional bytes Field15 = 15 [(gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinRepNative { + repeated double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + repeated float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + repeated int32 Field3 = 3 [(gogoproto.customname) = "FieldC"]; + repeated int64 Field4 = 4 [(gogoproto.customname) = "FieldD"]; + repeated uint32 Field5 = 5 [(gogoproto.customname) = "FieldE"]; + repeated uint64 Field6 = 6 [(gogoproto.customname) = "FieldF"]; + repeated sint32 Field7 = 7 [(gogoproto.customname) = "FieldG"]; + repeated sint64 Field8 = 8 [(gogoproto.customname) = "FieldH"]; + repeated fixed32 Field9 = 9 [(gogoproto.customname) = "FieldI"]; + repeated sfixed32 Field10 = 10 [(gogoproto.customname) = "FieldJ"]; + repeated fixed64 Field11 = 11 [(gogoproto.customname) = "FieldK"]; + repeated sfixed64 Field12 = 12 [(gogoproto.customname) = "FieldL"]; + repeated bool Field13 = 13 [(gogoproto.customname) = "FieldM"]; + repeated string Field14 = 14 [(gogoproto.customname) = "FieldN"]; + repeated bytes Field15 = 15 [(gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinStruct { + optional double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + optional NidOptNative Field3 = 3 [(gogoproto.customname) = "FieldC"]; + repeated NinOptNative Field4 = 4 [(gogoproto.customname) = "FieldD"]; + optional uint64 Field6 = 6 [(gogoproto.customname) = "FieldE"]; + optional sint32 Field7 = 7 [(gogoproto.customname) = "FieldF"]; + optional NidOptNative Field8 = 8 [(gogoproto.customname) = "FieldG"]; + optional bool Field13 = 13 [(gogoproto.customname) = "FieldH"]; + optional string Field14 = 14 [(gogoproto.customname) = "FieldI"]; + optional bytes Field15 = 15 [(gogoproto.customname) = "FieldJ"]; +} + +message CustomNameCustomType { + optional bytes Id = 1 [(gogoproto.customname) = "FieldA", (gogoproto.customtype) = "Uuid"]; + optional bytes Value = 2 [(gogoproto.customname) = "FieldB", (gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; + repeated bytes Ids = 3 [(gogoproto.customname) = "FieldC", (gogoproto.customtype) = "Uuid"]; + repeated bytes Values = 4 [(gogoproto.customname) = "FieldD", (gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message CustomNameNinEmbeddedStructUnion { + option (gogoproto.onlyone) = true; + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NinOptNative Field200 = 200 [(gogoproto.customname) = "FieldA"]; + optional bool Field210 = 210 [(gogoproto.customname) = "FieldB"]; +} + +message CustomNameEnum { + optional TheTestEnum Field1 = 1 [(gogoproto.customname) = "FieldA"]; + repeated TheTestEnum Field2 = 2 [(gogoproto.customname) = "FieldB"]; +} + +message NoExtensionsMap { + option (gogoproto.face) = false; + option (gogoproto.goproto_extensions_map) = false; + optional int64 Field1 = 1; + extensions 100 to 199; +} + +extend NoExtensionsMap { + optional double FieldA1 = 100; + optional NinOptNative FieldB1 = 101; + optional NinEmbeddedStruct FieldC1 = 102; +} + +message Unrecognized { + option (gogoproto.goproto_unrecognized) = false; + optional string Field1 = 1; +} + +message UnrecognizedWithInner { + message Inner { + option (gogoproto.goproto_unrecognized) = false; + optional uint32 Field1 = 1; + } + + repeated Inner embedded = 1; + optional string Field2 = 2; +} + +message UnrecognizedWithEmbed { + message Embedded { + option (gogoproto.goproto_unrecognized) = false; + optional uint32 Field1 = 1; + } + + optional Embedded embedded = 1 [(gogoproto.embed) = true, (gogoproto.nullable) = false]; + optional string Field2 = 2; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeboth/thetestpb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeboth/thetestpb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..0d64c2d595c7e7875a68fe144fa38e7f932f5c80 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeboth/thetestpb_test.go @@ -0,0 +1,14647 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeboth/thetest.proto +// DO NOT EDIT! + +/* +Package test is a generated protocol buffer package. + +It is generated from these files: + combos/unsafeboth/thetest.proto + +It has these top-level messages: + NidOptNative + NinOptNative + NidRepNative + NinRepNative + NidRepPackedNative + NinRepPackedNative + NidOptStruct + NinOptStruct + NidRepStruct + NinRepStruct + NidEmbeddedStruct + NinEmbeddedStruct + NidNestedStruct + NinNestedStruct + NidOptCustom + CustomDash + NinOptCustom + NidRepCustom + NinRepCustom + NinOptNativeUnion + NinOptStructUnion + NinEmbeddedStructUnion + NinNestedStructUnion + Tree + OrBranch + AndBranch + Leaf + DeepTree + ADeepBranch + AndDeepBranch + DeepLeaf + Nil + NidOptEnum + NinOptEnum + NidRepEnum + NinRepEnum + NinOptEnumDefault + AnotherNinOptEnum + AnotherNinOptEnumDefault + Timer + MyExtendable + OtherExtenable + NestedDefinition + NestedScope + NinOptNativeDefault + CustomContainer + CustomNameNidOptNative + CustomNameNinOptNative + CustomNameNinRepNative + CustomNameNinStruct + CustomNameCustomType + CustomNameNinEmbeddedStructUnion + CustomNameEnum + NoExtensionsMap + Unrecognized + UnrecognizedWithInner + UnrecognizedWithEmbed +*/ +package test + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestNidOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidOptNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepPackedNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepPackedNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepPackedNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepPackedNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepPackedNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepPackedNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepPackedNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepPackedNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepPackedNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepPackedNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepPackedNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepPackedNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepPackedNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepPackedNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidOptStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidOptStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidEmbeddedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidEmbeddedStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidEmbeddedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidEmbeddedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidEmbeddedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidEmbeddedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidEmbeddedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinEmbeddedStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinEmbeddedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinEmbeddedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinEmbeddedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidNestedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidNestedStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidNestedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidNestedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidNestedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidNestedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidNestedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinNestedStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinNestedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinNestedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinNestedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidOptCustomMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidOptCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomDashProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomDashMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomDashProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomDash, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomDash(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomDashProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomDash(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomDash{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptCustomMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepCustomMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepCustomMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptNativeUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptNativeUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNativeUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNativeUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptStructUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinEmbeddedStructUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinEmbeddedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinEmbeddedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinNestedStructUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinNestedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinNestedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinNestedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinNestedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestTreeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestTreeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkTreeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Tree, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkTreeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTree(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Tree{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestOrBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestOrBranchMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkOrBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OrBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedOrBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkOrBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOrBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &OrBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAndBranchMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAndBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAndBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAndBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AndBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestLeafProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestLeafMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkLeafProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Leaf, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkLeafProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLeaf(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Leaf{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepTreeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestDeepTreeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkDeepTreeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepTree, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedDeepTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkDeepTreeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepTree(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &DeepTree{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestADeepBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestADeepBranchMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkADeepBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*ADeepBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedADeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkADeepBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedADeepBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &ADeepBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndDeepBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAndDeepBranchMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAndDeepBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndDeepBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAndDeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAndDeepBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndDeepBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AndDeepBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepLeafProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestDeepLeafMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkDeepLeafProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepLeaf, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedDeepLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkDeepLeafProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepLeaf(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &DeepLeaf{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNilProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNilMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNilProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nil, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNil(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNilProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNil(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Nil{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidOptEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptEnumDefaultMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptEnumDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnumDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptEnumDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnumDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptEnumDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAnotherNinOptEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAnotherNinOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAnotherNinOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AnotherNinOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAnotherNinOptEnumDefaultMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAnotherNinOptEnumDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnumDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAnotherNinOptEnumDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnumDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AnotherNinOptEnumDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestTimerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestTimerMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkTimerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Timer, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedTimer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkTimerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTimer(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Timer{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMyExtendableProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestMyExtendableMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkMyExtendableProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MyExtendable, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMyExtendable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMyExtendableProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMyExtendable(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &MyExtendable{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestOtherExtenableProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestOtherExtenableMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkOtherExtenableProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OtherExtenable, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedOtherExtenable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkOtherExtenableProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOtherExtenable(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &OtherExtenable{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinitionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedDefinitionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedDefinitionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinitionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessageProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedDefinition_NestedMessageMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedDefinition_NestedMessageProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinition_NestedMessageProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition_NestedMessage{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedScopeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedScopeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedScopeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedScope, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedScope(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedScopeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedScope(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedScope{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptNativeDefaultMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptNativeDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNativeDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNativeDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomContainerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomContainerMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomContainerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomContainer, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomContainer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomContainerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomContainer(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomContainer{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNidOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNidOptNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNidOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNidOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNidOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNidOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNidOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNinOptNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNinOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNinRepNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNinRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNinStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNinStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameCustomTypeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameCustomTypeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameCustomTypeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameCustomType, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameCustomType(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameCustomTypeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameCustomType(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameCustomType{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinEmbeddedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNinEmbeddedStructUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNinEmbeddedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinEmbeddedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinEmbeddedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNoExtensionsMapProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNoExtensionsMapMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNoExtensionsMapProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NoExtensionsMap, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNoExtensionsMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNoExtensionsMapProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNoExtensionsMap(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NoExtensionsMap{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Unrecognized, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognized(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognized(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Unrecognized{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInnerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedWithInnerMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedWithInnerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithInnerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithInner{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInner_InnerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedWithInner_InnerMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedWithInner_InnerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner_Inner, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithInner_InnerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner_Inner(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithInner_Inner{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedWithEmbedMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedWithEmbedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithEmbedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithEmbed{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbed_EmbeddedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed_Embedded, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithEmbed_Embedded{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepPackedNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepPackedNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidEmbeddedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinEmbeddedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidNestedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinNestedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomDashJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinEmbeddedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinNestedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTreeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOrBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAndBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestLeafJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestDeepTreeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestADeepBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAndDeepBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestDeepLeafJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNilJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptEnumDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAnotherNinOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAnotherNinOptEnumDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTimerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMyExtendableJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOtherExtenableJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinitionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinition_NestedMessageJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedScopeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomContainerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNidOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameCustomTypeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNoExtensionsMapJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithInnerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithInner_InnerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithEmbedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithEmbed_EmbeddedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepPackedNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepPackedNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepPackedNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepPackedNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidEmbeddedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidEmbeddedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidNestedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidNestedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomDashProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomDashProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTreeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTreeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOrBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOrBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestLeafProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestLeafProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepTreeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepTreeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestADeepBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestADeepBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndDeepBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndDeepBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepLeafProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepLeafProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNilProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNilProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTimerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTimerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMyExtendableProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMyExtendableProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOtherExtenableProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOtherExtenableProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinitionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinitionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessageProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessageProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedScopeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedScopeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomContainerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomContainerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNidOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNidOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameCustomTypeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameCustomTypeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinEmbeddedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinEmbeddedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNoExtensionsMapProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNoExtensionsMapProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInnerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInnerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInner_InnerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInner_InnerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestThetestDescription(t *testing.T) { + ThetestDescription() +} +func TestNidOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepPackedNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepPackedNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidEmbeddedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinEmbeddedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidNestedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinNestedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomDashVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinNestedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTreeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOrBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAndBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestLeafVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestDeepTreeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestADeepBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAndDeepBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestDeepLeafVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNilVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptEnumDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAnotherNinOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAnotherNinOptEnumDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTimerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMyExtendableVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOtherExtenableVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinitionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinition_NestedMessageVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedScopeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomContainerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNidOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameCustomTypeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNoExtensionsMapVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithInnerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithInner_InnerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithEmbedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithEmbed_EmbeddedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepPackedNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepPackedNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidEmbeddedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidNestedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinNestedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomDashFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptNativeUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinNestedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestTreeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestOrBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAndBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestLeafFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestDeepTreeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestADeepBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAndDeepBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestDeepLeafFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNilFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAnotherNinOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestTimerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinitionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinition_NestedMessageFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedScopeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomContainerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNidOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameCustomTypeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithInnerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithInner_InnerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithEmbedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithEmbed_EmbeddedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepPackedNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepPackedNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidEmbeddedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinEmbeddedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidNestedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinNestedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomDashGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinEmbeddedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinNestedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTreeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOrBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAndBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestLeafGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestDeepTreeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestADeepBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAndDeepBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestDeepLeafGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNilGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptEnumDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAnotherNinOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAnotherNinOptEnumDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTimerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMyExtendableGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOtherExtenableGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinitionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinition_NestedMessageGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedScopeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomContainerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNidOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameCustomTypeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinEmbeddedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNoExtensionsMapGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithInnerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithInner_InnerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithEmbedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithEmbed_EmbeddedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepPackedNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepPackedNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepPackedNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepPackedNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepPackedNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepPackedNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidEmbeddedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidEmbeddedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidEmbeddedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinEmbeddedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidNestedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidNestedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidNestedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinNestedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomDashSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomDashSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomDash, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomDash(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNativeUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinEmbeddedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinNestedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinNestedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestTreeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkTreeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Tree, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestOrBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkOrBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OrBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedOrBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAndBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAndBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestLeafSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkLeafSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Leaf, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepTreeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkDeepTreeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepTree, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedDeepTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestADeepBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkADeepBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*ADeepBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedADeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndDeepBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAndDeepBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndDeepBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAndDeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepLeafSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkDeepLeafSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepLeaf, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedDeepLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNilSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNilSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nil, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNil(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptEnumDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnumDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAnotherNinOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAnotherNinOptEnumDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnumDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestTimerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkTimerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Timer, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedTimer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMyExtendableSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMyExtendableSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MyExtendable, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMyExtendable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestOtherExtenableSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkOtherExtenableSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OtherExtenable, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedOtherExtenable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinitionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinitionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessageSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinition_NestedMessageSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedScopeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedScopeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedScope, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedScope(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNativeDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomContainerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomContainerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomContainer, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomContainer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNidOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNidOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNidOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameCustomTypeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameCustomTypeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameCustomType, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameCustomType(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinEmbeddedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinEmbeddedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinEmbeddedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNoExtensionsMapSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNoExtensionsMapSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NoExtensionsMap, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNoExtensionsMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Unrecognized, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognized(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInnerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithInnerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInner_InnerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithInner_InnerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner_Inner, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithEmbedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbed_EmbeddedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed_Embedded, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepPackedNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepPackedNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidEmbeddedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinEmbeddedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidNestedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinNestedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomDashStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinEmbeddedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinNestedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTreeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOrBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAndBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestLeafStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestDeepTreeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestADeepBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAndDeepBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestDeepLeafStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNilStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptEnumDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAnotherNinOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAnotherNinOptEnumDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTimerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestMyExtendableStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOtherExtenableStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinitionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinition_NestedMessageStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedScopeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomContainerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNidOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameCustomTypeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinEmbeddedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNoExtensionsMapStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithInnerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithInner_InnerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithEmbedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithEmbed_EmbeddedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, true) + v := p.GetValue() + msg := &NinOptNativeUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinOptStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, true) + v := p.GetValue() + msg := &NinOptStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + v := p.GetValue() + msg := &NinEmbeddedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinNestedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, true) + v := p.GetValue() + msg := &NinNestedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestTreeOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, true) + v := p.GetValue() + msg := &Tree{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestDeepTreeOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, true) + v := p.GetValue() + msg := &DeepTree{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + v := p.GetValue() + msg := &CustomNameNinEmbeddedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeboth/uuid.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeboth/uuid.go new file mode 100644 index 0000000000000000000000000000000000000000..4c071114bcce237893cd1f0fa4baca9d8663b571 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeboth/uuid.go @@ -0,0 +1,122 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 test + +import ( + "bytes" + "encoding/json" +) + +func PutLittleEndianUint64(b []byte, offset int, v uint64) { + b[offset] = byte(v) + b[offset+1] = byte(v >> 8) + b[offset+2] = byte(v >> 16) + b[offset+3] = byte(v >> 24) + b[offset+4] = byte(v >> 32) + b[offset+5] = byte(v >> 40) + b[offset+6] = byte(v >> 48) + b[offset+7] = byte(v >> 56) +} + +type Uuid []byte + +func (uuid Uuid) Marshal() ([]byte, error) { + if len(uuid) == 0 { + return nil, nil + } + return []byte(uuid), nil +} + +func (uuid Uuid) MarshalTo(data []byte) (n int, err error) { + if len(uuid) == 0 { + return 0, nil + } + copy(data, uuid) + return 16, nil +} + +func (uuid *Uuid) Unmarshal(data []byte) error { + if len(data) == 0 { + uuid = nil + return nil + } + id := Uuid(make([]byte, 16)) + copy(id, data) + *uuid = id + return nil +} + +func (uuid *Uuid) Size() int { + if uuid == nil { + return 0 + } + if len(*uuid) == 0 { + return 0 + } + return 16 +} + +func (uuid Uuid) MarshalJSON() ([]byte, error) { + return json.Marshal([]byte(uuid)) +} + +func (uuid *Uuid) UnmarshalJSON(data []byte) error { + v := new([]byte) + err := json.Unmarshal(data, v) + if err != nil { + return err + } + return uuid.Unmarshal(*v) +} + +func (uuid Uuid) Equal(other Uuid) bool { + return bytes.Equal(uuid[0:], other[0:]) +} + +type int63 interface { + Int63() int64 +} + +func NewPopulatedUuid(r int63) *Uuid { + u := RandV4(r) + return &u +} + +func RandV4(r int63) Uuid { + uuid := make(Uuid, 16) + uuid.RandV4(r) + return uuid +} + +func (uuid Uuid) RandV4(r int63) { + PutLittleEndianUint64(uuid, 0, uint64(r.Int63())) + PutLittleEndianUint64(uuid, 8, uint64(r.Int63())) + uuid[6] = (uuid[6] & 0xf) | 0x40 + uuid[8] = (uuid[8] & 0x3f) | 0x80 +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafemarshaler/bug_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafemarshaler/bug_test.go new file mode 100644 index 0000000000000000000000000000000000000000..264d3982327d7276cc42c9314074f391dde60dfa --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafemarshaler/bug_test.go @@ -0,0 +1,186 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 test + +import ( + "fmt" + "math" + "testing" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +) + +//http://code.google.com/p/goprotobuf/issues/detail?id=39 +func TestBugUint32VarintSize(t *testing.T) { + temp := uint32(math.MaxUint32) + n := &NinOptNative{} + n.Field5 = &temp + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != 6 { + t.Fatalf("data should be length 6, but its %#v", data) + } +} + +func TestBugZeroLengthSliceSize(t *testing.T) { + n := &NinRepPackedNative{ + Field8: []int64{}, + } + size := n.Size() + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != size { + t.Fatalf("expected %v, but got %v", len(data), size) + } +} + +//http://code.google.com/p/goprotobuf/issues/detail?id=40 +func TestBugPackedProtoSize(t *testing.T) { + n := &NinRepPackedNative{ + Field4: []int64{172960727389894724, 2360337516664475010, 860833876131988189, 9068073014890763245, 7794843386260381831, 4023536436053141786, 8992311247496919020, 4330096163611305776, 4490411416244976467, 7873947349172707443, 2754969595834279669, 1360667855926938684, 4771480785172657389, 4875578924966668055, 8070579869808877481, 9128179594766551001, 4630419407064527516, 863844540220372892, 8208727650143073487, 7086117356301045838, 7779695211931506151, 5493835345187563535, 9119767633370806007, 9054342025895349248, 1887303228838508438, 7624573031734528281, 1874668389749611225, 3517684643468970593, 6677697606628877758, 7293473953189936168, 444475066704085538, 8594971141363049302, 1146643249094989673, 733393306232853371, 7721178528893916886, 7784452000911004429, 6436373110242711440, 6897422461738321237, 8772249155667732778, 6211871464311393541, 3061903718310406883, 7845488913176136641, 8342255034663902574, 3443058984649725748, 8410801047334832902, 7496541071517841153, 4305416923521577765, 7814967600020476457, 8671843803465481186, 3490266370361096855, 1447425664719091336, 653218597262334239, 8306243902880091940, 7851896059762409081, 5936760560798954978, 5755724498441478025, 7022701569985035966, 3707709584811468220, 529069456924666920, 7986469043681522462, 3092513330689518836, 5103541550470476202, 3577384161242626406, 3733428084624703294, 8388690542440473117, 3262468785346149388, 8788358556558007570, 5476276940198542020, 7277903243119461239, 5065861426928605020, 7533460976202697734, 1749213838654236956, 557497603941617931, 5496307611456481108, 6444547750062831720, 6992758776744205596, 7356719693428537399, 2896328872476734507, 381447079530132038, 598300737753233118, 3687980626612697715, 7240924191084283349, 8172414415307971170, 4847024388701257185, 2081764168600256551, 3394217778539123488, 6244660626429310923, 8301712215675381614, 5360615125359461174, 8410140945829785773, 3152963269026381373, 6197275282781459633, 4419829061407546410, 6262035523070047537, 2837207483933463885, 2158105736666826128, 8150764172235490711}, + Field7: []int32{249451845, 1409974015, 393609128, 435232428, 1817529040, 91769006, 861170933, 1556185603, 1568580279, 1236375273, 512276621, 693633711, 967580535, 1950715977, 853431462, 1362390253, 159591204, 111900629, 322985263, 279671129, 1592548430, 465651370, 733849989, 1172059400, 1574824441, 263541092, 1271612397, 1520584358, 467078791, 117698716, 1098255064, 2054264846, 1766452305, 1267576395, 1557505617, 1187833560, 956187431, 1970977586, 1160235159, 1610259028, 489585797, 459139078, 566263183, 954319278, 1545018565, 1753946743, 948214318, 422878159, 883926576, 1424009347, 824732372, 1290433180, 80297942, 417294230, 1402647904, 2078392782, 220505045, 787368129, 463781454, 293083578, 808156928, 293976361}, + Field9: []uint32{0xaa4976e8, 0x3da8cc4c, 0x8c470d83, 0x344d964e, 0x5b90925, 0xa4c4d34e, 0x666eff19, 0xc238e552, 0x9be53bb6, 0x56364245, 0x33ee079d, 0x96bf0ede, 0x7941b74f, 0xdb07cb47, 0x6d76d827, 0x9b211d5d, 0x2798adb6, 0xe48b0c3b, 0x87061b21, 0x48f4e4d2, 0x3e5d5c12, 0x5ee91288, 0x336d4f35, 0xe1d44941, 0xc065548d, 0x2953d73f, 0x873af451, 0xfc769db, 0x9f1bf8da, 0x9baafdfc, 0xf1d3d770, 0x5bb5d2b4, 0xc2c67c48, 0x6845c4c1, 0xa48f32b0, 0xbb04bb70, 0xa5b1ca36, 0x8d98356a, 0x2171f654, 0x5ae279b0, 0x6c4a3d6b, 0x4fff5468, 0xcf9bf851, 0x68513614, 0xdbecd9b0, 0x9553ed3c, 0xa494a736, 0x42205438, 0xbf8e5caa, 0xd3283c6, 0x76d20788, 0x9179826f, 0x96b24f85, 0xbc2eacf4, 0xe4afae0b, 0x4bca85cb, 0x35e63b5b, 0xd7ccee0c, 0x2b506bb9, 0xe78e9f44, 0x9ad232f1, 0x99a37335, 0xa5d6ffc8}, + Field11: []uint64{0x53c01ebc, 0x4fb85ba6, 0x8805eea1, 0xb20ec896, 0x93b63410, 0xec7c9492, 0x50765a28, 0x19592106, 0x2ecc59b3, 0x39cd474f, 0xe4c9e47, 0x444f48c5, 0xe7731d32, 0xf3f43975, 0x603caedd, 0xbb05a1af, 0xa808e34e, 0x88580b07, 0x4c96bbd1, 0x730b4ab9, 0xed126e2b, 0x6db48205, 0x154ba1b9, 0xc26bfb6a, 0x389aa052, 0x869d966c, 0x7c86b366, 0xcc8edbcd, 0xfa8d6dad, 0xcf5857d9, 0x2d9cda0f, 0x1218a0b8, 0x41bf997, 0xf0ca65ac, 0xa610d4b9, 0x8d362e28, 0xb7212d87, 0x8e0fe109, 0xbee041d9, 0x759be2f6, 0x35fef4f3, 0xaeacdb71, 0x10888852, 0xf4e28117, 0xe2a14812, 0x73b748dc, 0xd1c3c6b2, 0xfef41bf0, 0xc9b43b62, 0x810e4faa, 0xcaa41c06, 0x1893fe0d, 0xedc7c850, 0xd12b9eaa, 0x467ee1a9, 0xbe84756b, 0xda7b1680, 0xdc069ffe, 0xf1e7e9f9, 0xb3d95370, 0xa92b77df, 0x5693ac41, 0xd04b7287, 0x27aebf15, 0x837b316e, 0x4dbe2263, 0xbab70c67, 0x547dab21, 0x3c346c1f, 0xb8ef0e4e, 0xfe2d03ce, 0xe1d75955, 0xfec1306, 0xba35c23e, 0xb784ed04, 0x2a4e33aa, 0x7e19d09a, 0x3827c1fe, 0xf3a51561, 0xef765e2b, 0xb044256c, 0x62b322be, 0xf34d56be, 0xeb71b369, 0xffe1294f, 0x237fe8d0, 0x77a1473b, 0x239e1196, 0xdd19bf3d, 0x82c91fe1, 0x95361c57, 0xffea3f1b, 0x1a094c84}, + Field12: []int64{8308420747267165049, 3664160795077875961, 7868970059161834817, 7237335984251173739, 5254748003907196506, 3362259627111837480, 430460752854552122, 5119635556501066533, 1277716037866233522, 9185775384759813768, 833932430882717888, 7986528304451297640, 6792233378368656337, 2074207091120609721, 1788723326198279432, 7756514594746453657, 2283775964901597324, 3061497730110517191, 7733947890656120277, 626967303632386244, 7822928600388582821, 3489658753000061230, 168869995163005961, 248814782163480763, 477885608911386247, 4198422415674133867, 3379354662797976109, 9925112544736939, 1486335136459138480, 4561560414032850671, 1010864164014091267, 186722821683803084, 5106357936724819318, 1298160820191228988, 4675403242419953145, 7130634540106489752, 7101280006672440929, 7176058292431955718, 9109875054097770321, 6810974877085322872, 4736707874303993641, 8993135362721382187, 6857881554990254283, 3704748883307461680, 1099360832887634994, 5207691918707192633, 5984721695043995243}, + } + size := proto.Size(n) + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != size { + t.Fatalf("expected %v, but got %v diff is %v", len(data), size, len(data)-size) + } +} + +func testSize(m interface { + proto.Message + Size() int +}, desc string, expected int) ([]byte, error) { + data, err := proto.Marshal(m) + if err != nil { + return nil, err + } + protoSize := proto.Size(m) + mSize := m.Size() + lenData := len(data) + if protoSize != mSize || protoSize != lenData || mSize != lenData { + return nil, fmt.Errorf("%s proto.Size(m){%d} != m.Size(){%d} != len(data){%d}", desc, protoSize, mSize, lenData) + } + if got := protoSize; got != expected { + return nil, fmt.Errorf("%s proto.Size(m) got %d expected %d", desc, got, expected) + } + if got := mSize; got != expected { + return nil, fmt.Errorf("%s m.Size() got %d expected %d", desc, got, expected) + } + if got := lenData; got != expected { + return nil, fmt.Errorf("%s len(data) got %d expected %d", desc, got, expected) + } + return data, nil +} + +func TestInt32Int64Compatibility(t *testing.T) { + + //test nullable int32 and int64 + + data1, err := testSize(&NinOptNative{ + Field3: proto.Int32(-1), + }, "nullable", 11) + if err != nil { + t.Error(err) + } + //change marshaled data1 to unmarshal into 4th field which is an int64 + data1[0] = uint8(uint32(4 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + u1 := &NinOptNative{} + if err := proto.Unmarshal(data1, u1); err != nil { + t.Error(err) + } + if !u1.Equal(&NinOptNative{ + Field4: proto.Int64(-1), + }) { + t.Error("nullable unmarshaled int32 is not the same int64") + } + + //test non-nullable int32 and int64 + + data2, err := testSize(&NidOptNative{ + Field3: -1, + }, "non nullable", 67) + if err != nil { + t.Error(err) + } + //change marshaled data2 to unmarshal into 4th field which is an int64 + field3 := uint8(uint32(3 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + field4 := uint8(uint32(4 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + for i, c := range data2 { + if c == field4 { + data2[i] = field3 + } else if c == field3 { + data2[i] = field4 + } + } + u2 := &NidOptNative{} + if err := proto.Unmarshal(data2, u2); err != nil { + t.Error(err) + } + if !u2.Equal(&NidOptNative{ + Field4: -1, + }) { + t.Error("non nullable unmarshaled int32 is not the same int64") + } + + //test packed repeated int32 and int64 + + m4 := &NinRepPackedNative{ + Field3: []int32{-1}, + } + data4, err := testSize(m4, "packed", 12) + if err != nil { + t.Error(err) + } + u4 := &NinRepPackedNative{} + if err := proto.Unmarshal(data4, u4); err != nil { + t.Error(err) + } + if err := u4.VerboseEqual(m4); err != nil { + t.Fatalf("%#v", u4) + } + + //test repeated int32 and int64 + + if _, err := testSize(&NinRepNative{ + Field3: []int32{-1}, + }, "repeated", 11); err != nil { + t.Error(err) + } + + t.Logf("tested all") +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafemarshaler/thetest.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafemarshaler/thetest.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..54fcdf539da35ae2bd4b76c4bcfa5cf57df4b326 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafemarshaler/thetest.pb.go @@ -0,0 +1,25606 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafemarshaler/thetest.proto +// DO NOT EDIT! + +/* + Package test is a generated protocol buffer package. + + It is generated from these files: + combos/unsafemarshaler/thetest.proto + + It has these top-level messages: + NidOptNative + NinOptNative + NidRepNative + NinRepNative + NidRepPackedNative + NinRepPackedNative + NidOptStruct + NinOptStruct + NidRepStruct + NinRepStruct + NidEmbeddedStruct + NinEmbeddedStruct + NidNestedStruct + NinNestedStruct + NidOptCustom + CustomDash + NinOptCustom + NidRepCustom + NinRepCustom + NinOptNativeUnion + NinOptStructUnion + NinEmbeddedStructUnion + NinNestedStructUnion + Tree + OrBranch + AndBranch + Leaf + DeepTree + ADeepBranch + AndDeepBranch + DeepLeaf + Nil + NidOptEnum + NinOptEnum + NidRepEnum + NinRepEnum + NinOptEnumDefault + AnotherNinOptEnum + AnotherNinOptEnumDefault + Timer + MyExtendable + OtherExtenable + NestedDefinition + NestedScope + NinOptNativeDefault + CustomContainer + CustomNameNidOptNative + CustomNameNinOptNative + CustomNameNinRepNative + CustomNameNinStruct + CustomNameCustomType + CustomNameNinEmbeddedStructUnion + CustomNameEnum + NoExtensionsMap + Unrecognized + UnrecognizedWithInner + UnrecognizedWithEmbed +*/ +package test + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_custom "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom" +import github_com_gogo_protobuf_test_custom_dash_type "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom-dash-type" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" + +import unsafe "unsafe" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type TheTestEnum int32 + +const ( + A TheTestEnum = 0 + B TheTestEnum = 1 + C TheTestEnum = 2 +) + +var TheTestEnum_name = map[int32]string{ + 0: "A", + 1: "B", + 2: "C", +} +var TheTestEnum_value = map[string]int32{ + "A": 0, + "B": 1, + "C": 2, +} + +func (x TheTestEnum) Enum() *TheTestEnum { + p := new(TheTestEnum) + *p = x + return p +} +func (x TheTestEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(TheTestEnum_name, int32(x)) +} +func (x *TheTestEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(TheTestEnum_value, data, "TheTestEnum") + if err != nil { + return err + } + *x = TheTestEnum(value) + return nil +} + +type AnotherTestEnum int32 + +const ( + D AnotherTestEnum = 10 + E AnotherTestEnum = 11 +) + +var AnotherTestEnum_name = map[int32]string{ + 10: "D", + 11: "E", +} +var AnotherTestEnum_value = map[string]int32{ + "D": 10, + "E": 11, +} + +func (x AnotherTestEnum) Enum() *AnotherTestEnum { + p := new(AnotherTestEnum) + *p = x + return p +} +func (x AnotherTestEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(AnotherTestEnum_name, int32(x)) +} +func (x *AnotherTestEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(AnotherTestEnum_value, data, "AnotherTestEnum") + if err != nil { + return err + } + *x = AnotherTestEnum(value) + return nil +} + +type NestedDefinition_NestedEnum int32 + +const ( + TYPE_NESTED NestedDefinition_NestedEnum = 1 +) + +var NestedDefinition_NestedEnum_name = map[int32]string{ + 1: "TYPE_NESTED", +} +var NestedDefinition_NestedEnum_value = map[string]int32{ + "TYPE_NESTED": 1, +} + +func (x NestedDefinition_NestedEnum) Enum() *NestedDefinition_NestedEnum { + p := new(NestedDefinition_NestedEnum) + *p = x + return p +} +func (x NestedDefinition_NestedEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(NestedDefinition_NestedEnum_name, int32(x)) +} +func (x *NestedDefinition_NestedEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(NestedDefinition_NestedEnum_value, data, "NestedDefinition_NestedEnum") + if err != nil { + return err + } + *x = NestedDefinition_NestedEnum(value) + return nil +} + +type NidOptNative struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + Field3 int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3"` + Field4 int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4"` + Field5 uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5"` + Field6 uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8"` + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9"` + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10"` + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11"` + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12"` + Field13 bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + Field14 string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptNative) Reset() { *m = NidOptNative{} } +func (*NidOptNative) ProtoMessage() {} + +type NinOptNative struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"` + Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"` + Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"` + Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"` + Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNative) Reset() { *m = NinOptNative{} } +func (*NinOptNative) ProtoMessage() {} + +type NidRepNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepNative) Reset() { *m = NidRepNative{} } +func (*NidRepNative) ProtoMessage() {} + +type NinRepNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepNative) Reset() { *m = NinRepNative{} } +func (*NinRepNative) ProtoMessage() {} + +type NidRepPackedNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepPackedNative) Reset() { *m = NidRepPackedNative{} } +func (*NidRepPackedNative) ProtoMessage() {} + +type NinRepPackedNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepPackedNative) Reset() { *m = NinRepPackedNative{} } +func (*NinRepPackedNative) ProtoMessage() {} + +type NidOptStruct struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + Field3 NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3"` + Field4 NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4"` + Field6 uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + Field8 NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8"` + Field13 bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + Field14 string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptStruct) Reset() { *m = NidOptStruct{} } +func (*NidOptStruct) ProtoMessage() {} + +type NinOptStruct struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field8 *NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptStruct) Reset() { *m = NinOptStruct{} } +func (*NinOptStruct) ProtoMessage() {} + +type NidRepStruct struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []NidOptNative `protobuf:"bytes,3,rep,name=Field3" json:"Field3"` + Field4 []NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []NidOptNative `protobuf:"bytes,8,rep,name=Field8" json:"Field8"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepStruct) Reset() { *m = NidRepStruct{} } +func (*NidRepStruct) ProtoMessage() {} + +type NinRepStruct struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []*NidOptNative `protobuf:"bytes,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []*NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []*NidOptNative `protobuf:"bytes,8,rep,name=Field8" json:"Field8,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepStruct) Reset() { *m = NinRepStruct{} } +func (*NinRepStruct) ProtoMessage() {} + +type NidEmbeddedStruct struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 NidOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200"` + Field210 bool `protobuf:"varint,210,opt,name=Field210" json:"Field210"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidEmbeddedStruct) Reset() { *m = NidEmbeddedStruct{} } +func (*NidEmbeddedStruct) ProtoMessage() {} + +type NinEmbeddedStruct struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 *NidOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + Field210 *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinEmbeddedStruct) Reset() { *m = NinEmbeddedStruct{} } +func (*NinEmbeddedStruct) ProtoMessage() {} + +type NidNestedStruct struct { + Field1 NidOptStruct `protobuf:"bytes,1,opt,name=Field1" json:"Field1"` + Field2 []NidRepStruct `protobuf:"bytes,2,rep,name=Field2" json:"Field2"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidNestedStruct) Reset() { *m = NidNestedStruct{} } +func (*NidNestedStruct) ProtoMessage() {} + +type NinNestedStruct struct { + Field1 *NinOptStruct `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 []*NinRepStruct `protobuf:"bytes,2,rep,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinNestedStruct) Reset() { *m = NinNestedStruct{} } +func (*NinNestedStruct) ProtoMessage() {} + +type NidOptCustom struct { + Id Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id"` + Value github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptCustom) Reset() { *m = NidOptCustom{} } +func (*NidOptCustom) ProtoMessage() {} + +type CustomDash struct { + Value *github_com_gogo_protobuf_test_custom_dash_type.Bytes `protobuf:"bytes,1,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom-dash-type.Bytes" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomDash) Reset() { *m = CustomDash{} } +func (*CustomDash) ProtoMessage() {} + +type NinOptCustom struct { + Id *Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id,omitempty"` + Value *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptCustom) Reset() { *m = NinOptCustom{} } +func (*NinOptCustom) ProtoMessage() {} + +type NidRepCustom struct { + Id []Uuid `protobuf:"bytes,1,rep,name=Id,customtype=Uuid" json:"Id"` + Value []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepCustom) Reset() { *m = NidRepCustom{} } +func (*NidRepCustom) ProtoMessage() {} + +type NinRepCustom struct { + Id []Uuid `protobuf:"bytes,1,rep,name=Id,customtype=Uuid" json:"Id,omitempty"` + Value []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepCustom) Reset() { *m = NinRepCustom{} } +func (*NinRepCustom) ProtoMessage() {} + +type NinOptNativeUnion struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNativeUnion) Reset() { *m = NinOptNativeUnion{} } +func (*NinOptNativeUnion) ProtoMessage() {} + +type NinOptStructUnion struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptStructUnion) Reset() { *m = NinOptStructUnion{} } +func (*NinOptStructUnion) ProtoMessage() {} + +type NinEmbeddedStructUnion struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 *NinOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + Field210 *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinEmbeddedStructUnion) Reset() { *m = NinEmbeddedStructUnion{} } +func (*NinEmbeddedStructUnion) ProtoMessage() {} + +type NinNestedStructUnion struct { + Field1 *NinOptNativeUnion `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *NinOptStructUnion `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NinEmbeddedStructUnion `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinNestedStructUnion) Reset() { *m = NinNestedStructUnion{} } +func (*NinNestedStructUnion) ProtoMessage() {} + +type Tree struct { + Or *OrBranch `protobuf:"bytes,1,opt,name=Or" json:"Or,omitempty"` + And *AndBranch `protobuf:"bytes,2,opt,name=And" json:"And,omitempty"` + Leaf *Leaf `protobuf:"bytes,3,opt,name=Leaf" json:"Leaf,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Tree) Reset() { *m = Tree{} } +func (*Tree) ProtoMessage() {} + +type OrBranch struct { + Left Tree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right Tree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OrBranch) Reset() { *m = OrBranch{} } +func (*OrBranch) ProtoMessage() {} + +type AndBranch struct { + Left Tree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right Tree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AndBranch) Reset() { *m = AndBranch{} } +func (*AndBranch) ProtoMessage() {} + +type Leaf struct { + Value int64 `protobuf:"varint,1,opt,name=Value" json:"Value"` + StrValue string `protobuf:"bytes,2,opt,name=StrValue" json:"StrValue"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Leaf) Reset() { *m = Leaf{} } +func (*Leaf) ProtoMessage() {} + +type DeepTree struct { + Down *ADeepBranch `protobuf:"bytes,1,opt,name=Down" json:"Down,omitempty"` + And *AndDeepBranch `protobuf:"bytes,2,opt,name=And" json:"And,omitempty"` + Leaf *DeepLeaf `protobuf:"bytes,3,opt,name=Leaf" json:"Leaf,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeepTree) Reset() { *m = DeepTree{} } +func (*DeepTree) ProtoMessage() {} + +type ADeepBranch struct { + Down DeepTree `protobuf:"bytes,2,opt,name=Down" json:"Down"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ADeepBranch) Reset() { *m = ADeepBranch{} } +func (*ADeepBranch) ProtoMessage() {} + +type AndDeepBranch struct { + Left DeepTree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right DeepTree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AndDeepBranch) Reset() { *m = AndDeepBranch{} } +func (*AndDeepBranch) ProtoMessage() {} + +type DeepLeaf struct { + Tree Tree `protobuf:"bytes,1,opt,name=Tree" json:"Tree"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeepLeaf) Reset() { *m = DeepLeaf{} } +func (*DeepLeaf) ProtoMessage() {} + +type Nil struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *Nil) Reset() { *m = Nil{} } +func (*Nil) ProtoMessage() {} + +type NidOptEnum struct { + Field1 TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptEnum) Reset() { *m = NidOptEnum{} } +func (*NidOptEnum) ProtoMessage() {} + +type NinOptEnum struct { + Field1 *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptEnum) Reset() { *m = NinOptEnum{} } +func (*NinOptEnum) ProtoMessage() {} + +type NidRepEnum struct { + Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepEnum) Reset() { *m = NidRepEnum{} } +func (*NidRepEnum) ProtoMessage() {} + +type NinRepEnum struct { + Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepEnum) Reset() { *m = NinRepEnum{} } +func (*NinRepEnum) ProtoMessage() {} + +type NinOptEnumDefault struct { + Field1 *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum,def=2" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptEnumDefault) Reset() { *m = NinOptEnumDefault{} } +func (*NinOptEnumDefault) ProtoMessage() {} + +const Default_NinOptEnumDefault_Field1 TheTestEnum = C + +func (m *NinOptEnumDefault) GetField1() TheTestEnum { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_NinOptEnumDefault_Field1 +} + +type AnotherNinOptEnum struct { + Field1 *AnotherTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.AnotherTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AnotherNinOptEnum) Reset() { *m = AnotherNinOptEnum{} } +func (*AnotherNinOptEnum) ProtoMessage() {} + +type AnotherNinOptEnumDefault struct { + Field1 *AnotherTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.AnotherTestEnum,def=11" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AnotherNinOptEnumDefault) Reset() { *m = AnotherNinOptEnumDefault{} } +func (*AnotherNinOptEnumDefault) ProtoMessage() {} + +const Default_AnotherNinOptEnumDefault_Field1 AnotherTestEnum = E + +func (m *AnotherNinOptEnumDefault) GetField1() AnotherTestEnum { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_AnotherNinOptEnumDefault_Field1 +} + +type Timer struct { + Time1 int64 `protobuf:"fixed64,1,opt,name=Time1" json:"Time1"` + Time2 int64 `protobuf:"fixed64,2,opt,name=Time2" json:"Time2"` + Data []byte `protobuf:"bytes,3,opt,name=Data" json:"Data"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Timer) Reset() { *m = Timer{} } +func (*Timer) ProtoMessage() {} + +type MyExtendable struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MyExtendable) Reset() { *m = MyExtendable{} } +func (*MyExtendable) ProtoMessage() {} + +var extRange_MyExtendable = []proto.ExtensionRange{ + {100, 199}, +} + +func (*MyExtendable) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MyExtendable +} +func (m *MyExtendable) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type OtherExtenable struct { + Field2 *int64 `protobuf:"varint,2,opt,name=Field2" json:"Field2,omitempty"` + Field13 *int64 `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + M *MyExtendable `protobuf:"bytes,1,opt,name=M" json:"M,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OtherExtenable) Reset() { *m = OtherExtenable{} } +func (*OtherExtenable) ProtoMessage() {} + +var extRange_OtherExtenable = []proto.ExtensionRange{ + {14, 16}, + {10, 12}, +} + +func (*OtherExtenable) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_OtherExtenable +} +func (m *OtherExtenable) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type NestedDefinition struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + EnumField *NestedDefinition_NestedEnum `protobuf:"varint,2,opt,name=EnumField,enum=test.NestedDefinition_NestedEnum" json:"EnumField,omitempty"` + NNM *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,3,opt,name=NNM" json:"NNM,omitempty"` + NM *NestedDefinition_NestedMessage `protobuf:"bytes,4,opt,name=NM" json:"NM,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition) Reset() { *m = NestedDefinition{} } +func (*NestedDefinition) ProtoMessage() {} + +type NestedDefinition_NestedMessage struct { + NestedField1 *uint64 `protobuf:"fixed64,1,opt,name=NestedField1" json:"NestedField1,omitempty"` + NNM *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,2,opt,name=NNM" json:"NNM,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition_NestedMessage) Reset() { *m = NestedDefinition_NestedMessage{} } +func (*NestedDefinition_NestedMessage) ProtoMessage() {} + +type NestedDefinition_NestedMessage_NestedNestedMsg struct { + NestedNestedField1 *string `protobuf:"bytes,10,opt,name=NestedNestedField1" json:"NestedNestedField1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Reset() { + *m = NestedDefinition_NestedMessage_NestedNestedMsg{} +} +func (*NestedDefinition_NestedMessage_NestedNestedMsg) ProtoMessage() {} + +type NestedScope struct { + A *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,1,opt,name=A" json:"A,omitempty"` + B *NestedDefinition_NestedEnum `protobuf:"varint,2,opt,name=B,enum=test.NestedDefinition_NestedEnum" json:"B,omitempty"` + C *NestedDefinition_NestedMessage `protobuf:"bytes,3,opt,name=C" json:"C,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedScope) Reset() { *m = NestedScope{} } +func (*NestedScope) ProtoMessage() {} + +type NinOptNativeDefault struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1,def=1234.1234" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2,def=1234.1234" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3,def=1234" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4,def=1234" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5,def=1234" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6,def=1234" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7,def=1234" json:"Field7,omitempty"` + Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8,def=1234" json:"Field8,omitempty"` + Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9,def=1234" json:"Field9,omitempty"` + Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10,def=1234" json:"Field10,omitempty"` + Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11,def=1234" json:"Field11,omitempty"` + Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12,def=1234" json:"Field12,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13,def=1" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14,def=1234" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNativeDefault) Reset() { *m = NinOptNativeDefault{} } +func (*NinOptNativeDefault) ProtoMessage() {} + +const Default_NinOptNativeDefault_Field1 float64 = 1234.1234 +const Default_NinOptNativeDefault_Field2 float32 = 1234.1234 +const Default_NinOptNativeDefault_Field3 int32 = 1234 +const Default_NinOptNativeDefault_Field4 int64 = 1234 +const Default_NinOptNativeDefault_Field5 uint32 = 1234 +const Default_NinOptNativeDefault_Field6 uint64 = 1234 +const Default_NinOptNativeDefault_Field7 int32 = 1234 +const Default_NinOptNativeDefault_Field8 int64 = 1234 +const Default_NinOptNativeDefault_Field9 uint32 = 1234 +const Default_NinOptNativeDefault_Field10 int32 = 1234 +const Default_NinOptNativeDefault_Field11 uint64 = 1234 +const Default_NinOptNativeDefault_Field12 int64 = 1234 +const Default_NinOptNativeDefault_Field13 bool = true +const Default_NinOptNativeDefault_Field14 string = "1234" + +func (m *NinOptNativeDefault) GetField1() float64 { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_NinOptNativeDefault_Field1 +} + +func (m *NinOptNativeDefault) GetField2() float32 { + if m != nil && m.Field2 != nil { + return *m.Field2 + } + return Default_NinOptNativeDefault_Field2 +} + +func (m *NinOptNativeDefault) GetField3() int32 { + if m != nil && m.Field3 != nil { + return *m.Field3 + } + return Default_NinOptNativeDefault_Field3 +} + +func (m *NinOptNativeDefault) GetField4() int64 { + if m != nil && m.Field4 != nil { + return *m.Field4 + } + return Default_NinOptNativeDefault_Field4 +} + +func (m *NinOptNativeDefault) GetField5() uint32 { + if m != nil && m.Field5 != nil { + return *m.Field5 + } + return Default_NinOptNativeDefault_Field5 +} + +func (m *NinOptNativeDefault) GetField6() uint64 { + if m != nil && m.Field6 != nil { + return *m.Field6 + } + return Default_NinOptNativeDefault_Field6 +} + +func (m *NinOptNativeDefault) GetField7() int32 { + if m != nil && m.Field7 != nil { + return *m.Field7 + } + return Default_NinOptNativeDefault_Field7 +} + +func (m *NinOptNativeDefault) GetField8() int64 { + if m != nil && m.Field8 != nil { + return *m.Field8 + } + return Default_NinOptNativeDefault_Field8 +} + +func (m *NinOptNativeDefault) GetField9() uint32 { + if m != nil && m.Field9 != nil { + return *m.Field9 + } + return Default_NinOptNativeDefault_Field9 +} + +func (m *NinOptNativeDefault) GetField10() int32 { + if m != nil && m.Field10 != nil { + return *m.Field10 + } + return Default_NinOptNativeDefault_Field10 +} + +func (m *NinOptNativeDefault) GetField11() uint64 { + if m != nil && m.Field11 != nil { + return *m.Field11 + } + return Default_NinOptNativeDefault_Field11 +} + +func (m *NinOptNativeDefault) GetField12() int64 { + if m != nil && m.Field12 != nil { + return *m.Field12 + } + return Default_NinOptNativeDefault_Field12 +} + +func (m *NinOptNativeDefault) GetField13() bool { + if m != nil && m.Field13 != nil { + return *m.Field13 + } + return Default_NinOptNativeDefault_Field13 +} + +func (m *NinOptNativeDefault) GetField14() string { + if m != nil && m.Field14 != nil { + return *m.Field14 + } + return Default_NinOptNativeDefault_Field14 +} + +func (m *NinOptNativeDefault) GetField15() []byte { + if m != nil { + return m.Field15 + } + return nil +} + +type CustomContainer struct { + CustomStruct NidOptCustom `protobuf:"bytes,1,opt,name=CustomStruct" json:"CustomStruct"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomContainer) Reset() { *m = CustomContainer{} } +func (*CustomContainer) ProtoMessage() {} + +type CustomNameNidOptNative struct { + FieldA float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + FieldB float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + FieldC int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3"` + FieldD int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4"` + FieldE uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5"` + FieldF uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + FieldG int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + FieldH int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8"` + FieldI uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9"` + FieldJ int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10"` + FieldK uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11"` + FieldL int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12"` + FieldM bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + FieldN string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + FieldO []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNidOptNative) Reset() { *m = CustomNameNidOptNative{} } +func (*CustomNameNidOptNative) ProtoMessage() {} + +type CustomNameNinOptNative struct { + FieldA *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + FieldB *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + FieldC *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + FieldD *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + FieldE *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + FieldF *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + FieldG *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + FieldH *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"` + FieldI *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"` + FieldJ *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"` + FieldK *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"` + FielL *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"` + FieldM *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + FieldN *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + FieldO []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinOptNative) Reset() { *m = CustomNameNinOptNative{} } +func (*CustomNameNinOptNative) ProtoMessage() {} + +type CustomNameNinRepNative struct { + FieldA []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + FieldB []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + FieldC []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + FieldD []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + FieldE []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + FieldF []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + FieldG []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + FieldH []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + FieldI []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + FieldJ []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + FieldK []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + FieldL []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + FieldM []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + FieldN []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + FieldO [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinRepNative) Reset() { *m = CustomNameNinRepNative{} } +func (*CustomNameNinRepNative) ProtoMessage() {} + +type CustomNameNinStruct struct { + FieldA *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + FieldB *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + FieldC *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + FieldD []*NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4,omitempty"` + FieldE *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + FieldF *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + FieldG *NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"` + FieldH *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + FieldI *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + FieldJ []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinStruct) Reset() { *m = CustomNameNinStruct{} } +func (*CustomNameNinStruct) ProtoMessage() {} + +type CustomNameCustomType struct { + FieldA *Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id,omitempty"` + FieldB *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + FieldC []Uuid `protobuf:"bytes,3,rep,name=Ids,customtype=Uuid" json:"Ids,omitempty"` + FieldD []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,4,rep,name=Values,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Values,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameCustomType) Reset() { *m = CustomNameCustomType{} } +func (*CustomNameCustomType) ProtoMessage() {} + +type CustomNameNinEmbeddedStructUnion struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + FieldA *NinOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + FieldB *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinEmbeddedStructUnion) Reset() { *m = CustomNameNinEmbeddedStructUnion{} } +func (*CustomNameNinEmbeddedStructUnion) ProtoMessage() {} + +type CustomNameEnum struct { + FieldA *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + FieldB []TheTestEnum `protobuf:"varint,2,rep,name=Field2,enum=test.TheTestEnum" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameEnum) Reset() { *m = CustomNameEnum{} } +func (*CustomNameEnum) ProtoMessage() {} + +type NoExtensionsMap struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + XXX_extensions []byte `protobuf:"bytes,0,opt" json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NoExtensionsMap) Reset() { *m = NoExtensionsMap{} } +func (*NoExtensionsMap) ProtoMessage() {} + +var extRange_NoExtensionsMap = []proto.ExtensionRange{ + {100, 199}, +} + +func (*NoExtensionsMap) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_NoExtensionsMap +} +func (m *NoExtensionsMap) GetExtensions() *[]byte { + if m.XXX_extensions == nil { + m.XXX_extensions = make([]byte, 0) + } + return &m.XXX_extensions +} + +type Unrecognized struct { + Field1 *string `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *Unrecognized) Reset() { *m = Unrecognized{} } +func (*Unrecognized) ProtoMessage() {} + +type UnrecognizedWithInner struct { + Embedded []*UnrecognizedWithInner_Inner `protobuf:"bytes,1,rep,name=embedded" json:"embedded,omitempty"` + Field2 *string `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnrecognizedWithInner) Reset() { *m = UnrecognizedWithInner{} } +func (*UnrecognizedWithInner) ProtoMessage() {} + +type UnrecognizedWithInner_Inner struct { + Field1 *uint32 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *UnrecognizedWithInner_Inner) Reset() { *m = UnrecognizedWithInner_Inner{} } +func (*UnrecognizedWithInner_Inner) ProtoMessage() {} + +type UnrecognizedWithEmbed struct { + UnrecognizedWithEmbed_Embedded `protobuf:"bytes,1,opt,name=embedded,embedded=embedded" json:"embedded"` + Field2 *string `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnrecognizedWithEmbed) Reset() { *m = UnrecognizedWithEmbed{} } +func (*UnrecognizedWithEmbed) ProtoMessage() {} + +type UnrecognizedWithEmbed_Embedded struct { + Field1 *uint32 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *UnrecognizedWithEmbed_Embedded) Reset() { *m = UnrecognizedWithEmbed_Embedded{} } +func (*UnrecognizedWithEmbed_Embedded) ProtoMessage() {} + +var E_FieldA = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*float64)(nil), + Field: 100, + Name: "test.FieldA", + Tag: "fixed64,100,opt,name=FieldA", +} + +var E_FieldB = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*NinOptNative)(nil), + Field: 101, + Name: "test.FieldB", + Tag: "bytes,101,opt,name=FieldB", +} + +var E_FieldC = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*NinEmbeddedStruct)(nil), + Field: 102, + Name: "test.FieldC", + Tag: "bytes,102,opt,name=FieldC", +} + +var E_FieldA1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*float64)(nil), + Field: 100, + Name: "test.FieldA1", + Tag: "fixed64,100,opt,name=FieldA1", +} + +var E_FieldB1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*NinOptNative)(nil), + Field: 101, + Name: "test.FieldB1", + Tag: "bytes,101,opt,name=FieldB1", +} + +var E_FieldC1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*NinEmbeddedStruct)(nil), + Field: 102, + Name: "test.FieldC1", + Tag: "bytes,102,opt,name=FieldC1", +} + +func init() { + proto.RegisterEnum("test.TheTestEnum", TheTestEnum_name, TheTestEnum_value) + proto.RegisterEnum("test.AnotherTestEnum", AnotherTestEnum_name, AnotherTestEnum_value) + proto.RegisterEnum("test.NestedDefinition_NestedEnum", NestedDefinition_NestedEnum_name, NestedDefinition_NestedEnum_value) + proto.RegisterExtension(E_FieldA) + proto.RegisterExtension(E_FieldB) + proto.RegisterExtension(E_FieldC) + proto.RegisterExtension(E_FieldA1) + proto.RegisterExtension(E_FieldB1) + proto.RegisterExtension(E_FieldC1) +} +func (this *NidOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepPackedNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepPackedNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidEmbeddedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinEmbeddedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidNestedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinNestedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomDash) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNativeUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinEmbeddedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinNestedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Tree) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *OrBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AndBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Leaf) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *DeepTree) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *ADeepBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AndDeepBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *DeepLeaf) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Nil) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptEnumDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AnotherNinOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AnotherNinOptEnumDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Timer) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *MyExtendable) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *OtherExtenable) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition_NestedMessage) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedScope) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNativeDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomContainer) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNidOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameCustomType) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinEmbeddedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NoExtensionsMap) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Unrecognized) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithInner) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithInner_Inner) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithEmbed) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithEmbed_Embedded) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func ThetestDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unsafemarshaler/thetest.proto"), + Package: func(v string) *string { return &v }("test"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NinRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NidOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }, {Name: func(v string) *string { return &v }("NidNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidRepStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStruct"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinRepStruct"), + }}, + }, {Name: func(v string) *string { return &v }("NidOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomDash"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x64, 0x61, 0x73, 0x68, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NidRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinOptStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinNestedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNativeUnion"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStructUnion"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStructUnion"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Tree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Or"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.OrBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Leaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("OrBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Leaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("StrValue"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepTree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.ADeepBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndDeepBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepLeaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("ADeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndDeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepLeaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Tree"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Nil")}, {Name: func(v string) *string { return &v }("NidOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NidRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + DefaultValue: func(v string) *string { return &v }("C"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + DefaultValue: func(v string) *string { return &v }("E"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Timer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Time1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Time2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Data"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("MyExtendable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("OtherExtenable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("M"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.MyExtendable"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(14), + End: func(v int32) *int32 { return &v }(17), + }, {Start: func(v int32) *int32 { return &v }(10), + End: func(v int32) *int32 { return &v }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("NestedDefinition"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("EnumField"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("NM"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedMessage"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedField1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedMsg"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedField1"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("NestedEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_NESTED"), + Number: func(v int32) *int32 { return &v }(1), + }}, + }}, + }, {Name: func(v string) *string { return &v }("NestedScope"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("true"), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("CustomContainer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("CustomStruct"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptCustom"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x5, 0x46, 0x69, 0x65, 0x6c, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameCustomType"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Ids"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Values"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("CustomNameEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + }, {Name: func(v string) *string { return &v }("NoExtensionsMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0}), 64025: proto.NewExtension([]byte{0xc8, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Unrecognized"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithInner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithInner.Inner"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Inner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithEmbed"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithEmbed.Embedded"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Embedded"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("TheTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }, {Name: func(v string) *string { return &v }("AnotherTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("D"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("E"), + Number: func(v int32) *int32 { return &v }(11), + }}, + Options: &google_protobuf.EnumOptions{XXX_extensions: map[int32]proto.Extension{62001: proto.NewExtension([]byte{0x88, 0xa3, 0x1e, 0x0})}}, + }}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("FieldA"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldB"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldC"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldA1"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldB1"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldC1"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x1}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (x TheTestEnum) String() string { + s, ok := TheTestEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x AnotherTestEnum) String() string { + s, ok := AnotherTestEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x NestedDefinition_NestedEnum) String() string { + s, ok := NestedDefinition_NestedEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *NidOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptNative) + if !ok { + return fmt.Errorf("that is not of type *NidOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptNativebut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if this.Field2 != that1.Field2 { + return false + } + if this.Field3 != that1.Field3 { + return false + } + if this.Field4 != that1.Field4 { + return false + } + if this.Field5 != that1.Field5 { + return false + } + if this.Field6 != that1.Field6 { + return false + } + if this.Field7 != that1.Field7 { + return false + } + if this.Field8 != that1.Field8 { + return false + } + if this.Field9 != that1.Field9 { + return false + } + if this.Field10 != that1.Field10 { + return false + } + if this.Field11 != that1.Field11 { + return false + } + if this.Field12 != that1.Field12 { + return false + } + if this.Field13 != that1.Field13 { + return false + } + if this.Field14 != that1.Field14 { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNative) + if !ok { + return fmt.Errorf("that is not of type *NinOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativebut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", *this.Field8, *that1.Field8) + } + } else if this.Field8 != nil { + return fmt.Errorf("this.Field8 == nil && that.Field8 != nil") + } else if that1.Field8 != nil { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", *this.Field9, *that1.Field9) + } + } else if this.Field9 != nil { + return fmt.Errorf("this.Field9 == nil && that.Field9 != nil") + } else if that1.Field9 != nil { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", *this.Field10, *that1.Field10) + } + } else if this.Field10 != nil { + return fmt.Errorf("this.Field10 == nil && that.Field10 != nil") + } else if that1.Field10 != nil { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", *this.Field11, *that1.Field11) + } + } else if this.Field11 != nil { + return fmt.Errorf("this.Field11 == nil && that.Field11 != nil") + } else if that1.Field11 != nil { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", *this.Field12, *that1.Field12) + } + } else if this.Field12 != nil { + return fmt.Errorf("this.Field12 == nil && that.Field12 != nil") + } else if that1.Field12 != nil { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return false + } + } else if this.Field8 != nil { + return false + } else if that1.Field8 != nil { + return false + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return false + } + } else if this.Field9 != nil { + return false + } else if that1.Field9 != nil { + return false + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return false + } + } else if this.Field10 != nil { + return false + } else if that1.Field10 != nil { + return false + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return false + } + } else if this.Field11 != nil { + return false + } else if that1.Field11 != nil { + return false + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return false + } + } else if this.Field12 != nil { + return false + } else if that1.Field12 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepNative) + if !ok { + return fmt.Errorf("that is not of type *NidRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepNative) + if !ok { + return fmt.Errorf("that is not of type *NinRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepPackedNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepPackedNative) + if !ok { + return fmt.Errorf("that is not of type *NidRepPackedNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepPackedNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepPackedNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepPackedNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepPackedNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepPackedNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepPackedNative) + if !ok { + return fmt.Errorf("that is not of type *NinRepPackedNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepPackedNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepPackedNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepPackedNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepPackedNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptStruct) + if !ok { + return fmt.Errorf("that is not of type *NidOptStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptStructbut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(&that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(&that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if !this.Field8.Equal(&that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if this.Field2 != that1.Field2 { + return false + } + if !this.Field3.Equal(&that1.Field3) { + return false + } + if !this.Field4.Equal(&that1.Field4) { + return false + } + if this.Field6 != that1.Field6 { + return false + } + if this.Field7 != that1.Field7 { + return false + } + if !this.Field8.Equal(&that1.Field8) { + return false + } + if this.Field13 != that1.Field13 { + return false + } + if this.Field14 != that1.Field14 { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptStruct) + if !ok { + return fmt.Errorf("that is not of type *NinOptStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptStructbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if !this.Field8.Equal(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !this.Field4.Equal(that1.Field4) { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if !this.Field8.Equal(that1.Field8) { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepStruct) + if !ok { + return fmt.Errorf("that is not of type *NidRepStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepStructbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if !this.Field3[i].Equal(&that1.Field3[i]) { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if !this.Field4[i].Equal(&that1.Field4[i]) { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if !this.Field8[i].Equal(&that1.Field8[i]) { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if !this.Field3[i].Equal(&that1.Field3[i]) { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if !this.Field4[i].Equal(&that1.Field4[i]) { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if !this.Field8[i].Equal(&that1.Field8[i]) { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepStruct) + if !ok { + return fmt.Errorf("that is not of type *NinRepStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepStructbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if !this.Field3[i].Equal(that1.Field3[i]) { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if !this.Field4[i].Equal(that1.Field4[i]) { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if !this.Field8[i].Equal(that1.Field8[i]) { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if !this.Field3[i].Equal(that1.Field3[i]) { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if !this.Field4[i].Equal(that1.Field4[i]) { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if !this.Field8[i].Equal(that1.Field8[i]) { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidEmbeddedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidEmbeddedStruct) + if !ok { + return fmt.Errorf("that is not of type *NidEmbeddedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidEmbeddedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidEmbeddedStructbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(&that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidEmbeddedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidEmbeddedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(&that1.Field200) { + return false + } + if this.Field210 != that1.Field210 { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinEmbeddedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinEmbeddedStruct) + if !ok { + return fmt.Errorf("that is not of type *NinEmbeddedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinEmbeddedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinEmbeddedStructbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", *this.Field210, *that1.Field210) + } + } else if this.Field210 != nil { + return fmt.Errorf("this.Field210 == nil && that.Field210 != nil") + } else if that1.Field210 != nil { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinEmbeddedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinEmbeddedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(that1.Field200) { + return false + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return false + } + } else if this.Field210 != nil { + return false + } else if that1.Field210 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidNestedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidNestedStruct) + if !ok { + return fmt.Errorf("that is not of type *NidNestedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidNestedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidNestedStructbut is not nil && this == nil") + } + if !this.Field1.Equal(&that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if !this.Field2[i].Equal(&that1.Field2[i]) { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidNestedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidNestedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(&that1.Field1) { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if !this.Field2[i].Equal(&that1.Field2[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinNestedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinNestedStruct) + if !ok { + return fmt.Errorf("that is not of type *NinNestedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinNestedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinNestedStructbut is not nil && this == nil") + } + if !this.Field1.Equal(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if !this.Field2[i].Equal(that1.Field2[i]) { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinNestedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinNestedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(that1.Field1) { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if !this.Field2[i].Equal(that1.Field2[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptCustom) + if !ok { + return fmt.Errorf("that is not of type *NidOptCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptCustombut is not nil && this == nil") + } + if !this.Id.Equal(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id) + } + if !this.Value.Equal(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Id.Equal(that1.Id) { + return false + } + if !this.Value.Equal(that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomDash) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomDash) + if !ok { + return fmt.Errorf("that is not of type *CustomDash") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomDash but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomDashbut is not nil && this == nil") + } + if that1.Value == nil { + if this.Value != nil { + return fmt.Errorf("this.Value != nil && that1.Value == nil") + } + } else if !this.Value.Equal(*that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomDash) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomDash) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Value == nil { + if this.Value != nil { + return false + } + } else if !this.Value.Equal(*that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptCustom) + if !ok { + return fmt.Errorf("that is not of type *NinOptCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptCustombut is not nil && this == nil") + } + if that1.Id == nil { + if this.Id != nil { + return fmt.Errorf("this.Id != nil && that1.Id == nil") + } + } else if !this.Id.Equal(*that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id) + } + if that1.Value == nil { + if this.Value != nil { + return fmt.Errorf("this.Value != nil && that1.Value == nil") + } + } else if !this.Value.Equal(*that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Id == nil { + if this.Id != nil { + return false + } + } else if !this.Id.Equal(*that1.Id) { + return false + } + if that1.Value == nil { + if this.Value != nil { + return false + } + } else if !this.Value.Equal(*that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepCustom) + if !ok { + return fmt.Errorf("that is not of type *NidRepCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepCustombut is not nil && this == nil") + } + if len(this.Id) != len(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", len(this.Id), len(that1.Id)) + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return fmt.Errorf("Id this[%v](%v) Not Equal that[%v](%v)", i, this.Id[i], i, that1.Id[i]) + } + } + if len(this.Value) != len(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", len(this.Value), len(that1.Value)) + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return fmt.Errorf("Value this[%v](%v) Not Equal that[%v](%v)", i, this.Value[i], i, that1.Value[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Id) != len(that1.Id) { + return false + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return false + } + } + if len(this.Value) != len(that1.Value) { + return false + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepCustom) + if !ok { + return fmt.Errorf("that is not of type *NinRepCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepCustombut is not nil && this == nil") + } + if len(this.Id) != len(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", len(this.Id), len(that1.Id)) + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return fmt.Errorf("Id this[%v](%v) Not Equal that[%v](%v)", i, this.Id[i], i, that1.Id[i]) + } + } + if len(this.Value) != len(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", len(this.Value), len(that1.Value)) + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return fmt.Errorf("Value this[%v](%v) Not Equal that[%v](%v)", i, this.Value[i], i, that1.Value[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Id) != len(that1.Id) { + return false + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return false + } + } + if len(this.Value) != len(that1.Value) { + return false + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNativeUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNativeUnion) + if !ok { + return fmt.Errorf("that is not of type *NinOptNativeUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNativeUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativeUnionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNativeUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNativeUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinOptStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptStructUnionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !this.Field4.Equal(that1.Field4) { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinEmbeddedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinEmbeddedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinEmbeddedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinEmbeddedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinEmbeddedStructUnionbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", *this.Field210, *that1.Field210) + } + } else if this.Field210 != nil { + return fmt.Errorf("this.Field210 == nil && that.Field210 != nil") + } else if that1.Field210 != nil { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinEmbeddedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinEmbeddedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(that1.Field200) { + return false + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return false + } + } else if this.Field210 != nil { + return false + } else if that1.Field210 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinNestedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinNestedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinNestedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinNestedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinNestedStructUnionbut is not nil && this == nil") + } + if !this.Field1.Equal(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !this.Field2.Equal(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinNestedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinNestedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(that1.Field1) { + return false + } + if !this.Field2.Equal(that1.Field2) { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Tree) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Tree) + if !ok { + return fmt.Errorf("that is not of type *Tree") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Tree but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Treebut is not nil && this == nil") + } + if !this.Or.Equal(that1.Or) { + return fmt.Errorf("Or this(%v) Not Equal that(%v)", this.Or, that1.Or) + } + if !this.And.Equal(that1.And) { + return fmt.Errorf("And this(%v) Not Equal that(%v)", this.And, that1.And) + } + if !this.Leaf.Equal(that1.Leaf) { + return fmt.Errorf("Leaf this(%v) Not Equal that(%v)", this.Leaf, that1.Leaf) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Tree) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Tree) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Or.Equal(that1.Or) { + return false + } + if !this.And.Equal(that1.And) { + return false + } + if !this.Leaf.Equal(that1.Leaf) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OrBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OrBranch) + if !ok { + return fmt.Errorf("that is not of type *OrBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OrBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OrBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OrBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OrBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AndBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AndBranch) + if !ok { + return fmt.Errorf("that is not of type *AndBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AndBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AndBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AndBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AndBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Leaf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Leaf) + if !ok { + return fmt.Errorf("that is not of type *Leaf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Leaf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Leafbut is not nil && this == nil") + } + if this.Value != that1.Value { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if this.StrValue != that1.StrValue { + return fmt.Errorf("StrValue this(%v) Not Equal that(%v)", this.StrValue, that1.StrValue) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Leaf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Leaf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Value != that1.Value { + return false + } + if this.StrValue != that1.StrValue { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *DeepTree) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*DeepTree) + if !ok { + return fmt.Errorf("that is not of type *DeepTree") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *DeepTree but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *DeepTreebut is not nil && this == nil") + } + if !this.Down.Equal(that1.Down) { + return fmt.Errorf("Down this(%v) Not Equal that(%v)", this.Down, that1.Down) + } + if !this.And.Equal(that1.And) { + return fmt.Errorf("And this(%v) Not Equal that(%v)", this.And, that1.And) + } + if !this.Leaf.Equal(that1.Leaf) { + return fmt.Errorf("Leaf this(%v) Not Equal that(%v)", this.Leaf, that1.Leaf) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *DeepTree) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*DeepTree) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Down.Equal(that1.Down) { + return false + } + if !this.And.Equal(that1.And) { + return false + } + if !this.Leaf.Equal(that1.Leaf) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *ADeepBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*ADeepBranch) + if !ok { + return fmt.Errorf("that is not of type *ADeepBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *ADeepBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *ADeepBranchbut is not nil && this == nil") + } + if !this.Down.Equal(&that1.Down) { + return fmt.Errorf("Down this(%v) Not Equal that(%v)", this.Down, that1.Down) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *ADeepBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*ADeepBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Down.Equal(&that1.Down) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AndDeepBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AndDeepBranch) + if !ok { + return fmt.Errorf("that is not of type *AndDeepBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AndDeepBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AndDeepBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AndDeepBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AndDeepBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *DeepLeaf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*DeepLeaf) + if !ok { + return fmt.Errorf("that is not of type *DeepLeaf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *DeepLeaf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *DeepLeafbut is not nil && this == nil") + } + if !this.Tree.Equal(&that1.Tree) { + return fmt.Errorf("Tree this(%v) Not Equal that(%v)", this.Tree, that1.Tree) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *DeepLeaf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*DeepLeaf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Tree.Equal(&that1.Tree) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Nil) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Nil) + if !ok { + return fmt.Errorf("that is not of type *Nil") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Nil but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Nilbut is not nil && this == nil") + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Nil) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Nil) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptEnum) + if !ok { + return fmt.Errorf("that is not of type *NidOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptEnumbut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptEnum) + if !ok { + return fmt.Errorf("that is not of type *NinOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptEnumbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepEnum) + if !ok { + return fmt.Errorf("that is not of type *NidRepEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepEnumbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepEnum) + if !ok { + return fmt.Errorf("that is not of type *NinRepEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepEnumbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptEnumDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptEnumDefault) + if !ok { + return fmt.Errorf("that is not of type *NinOptEnumDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptEnumDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptEnumDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptEnumDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptEnumDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AnotherNinOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AnotherNinOptEnum) + if !ok { + return fmt.Errorf("that is not of type *AnotherNinOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AnotherNinOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AnotherNinOptEnumbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AnotherNinOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AnotherNinOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AnotherNinOptEnumDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AnotherNinOptEnumDefault) + if !ok { + return fmt.Errorf("that is not of type *AnotherNinOptEnumDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AnotherNinOptEnumDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AnotherNinOptEnumDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AnotherNinOptEnumDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AnotherNinOptEnumDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Timer) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Timer) + if !ok { + return fmt.Errorf("that is not of type *Timer") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Timer but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Timerbut is not nil && this == nil") + } + if this.Time1 != that1.Time1 { + return fmt.Errorf("Time1 this(%v) Not Equal that(%v)", this.Time1, that1.Time1) + } + if this.Time2 != that1.Time2 { + return fmt.Errorf("Time2 this(%v) Not Equal that(%v)", this.Time2, that1.Time2) + } + if !bytes.Equal(this.Data, that1.Data) { + return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Timer) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Timer) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Time1 != that1.Time1 { + return false + } + if this.Time2 != that1.Time2 { + return false + } + if !bytes.Equal(this.Data, that1.Data) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *MyExtendable) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*MyExtendable) + if !ok { + return fmt.Errorf("that is not of type *MyExtendable") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *MyExtendable but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *MyExtendablebut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return fmt.Errorf("XXX_extensions this[%v](%v) Not Equal that[%v](%v)", k, this.XXX_extensions[k], k, that1.XXX_extensions[k]) + } + } else { + return fmt.Errorf("XXX_extensions[%v] Not In that", k) + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return fmt.Errorf("XXX_extensions[%v] Not In this", k) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *MyExtendable) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*MyExtendable) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return false + } + } else { + return false + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OtherExtenable) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OtherExtenable) + if !ok { + return fmt.Errorf("that is not of type *OtherExtenable") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OtherExtenable but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OtherExtenablebut is not nil && this == nil") + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if !this.M.Equal(that1.M) { + return fmt.Errorf("M this(%v) Not Equal that(%v)", this.M, that1.M) + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return fmt.Errorf("XXX_extensions this[%v](%v) Not Equal that[%v](%v)", k, this.XXX_extensions[k], k, that1.XXX_extensions[k]) + } + } else { + return fmt.Errorf("XXX_extensions[%v] Not In that", k) + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return fmt.Errorf("XXX_extensions[%v] Not In this", k) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OtherExtenable) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OtherExtenable) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if !this.M.Equal(that1.M) { + return false + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return false + } + } else { + return false + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinitionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.EnumField != nil && that1.EnumField != nil { + if *this.EnumField != *that1.EnumField { + return fmt.Errorf("EnumField this(%v) Not Equal that(%v)", *this.EnumField, *that1.EnumField) + } + } else if this.EnumField != nil { + return fmt.Errorf("this.EnumField == nil && that.EnumField != nil") + } else if that1.EnumField != nil { + return fmt.Errorf("EnumField this(%v) Not Equal that(%v)", this.EnumField, that1.EnumField) + } + if !this.NNM.Equal(that1.NNM) { + return fmt.Errorf("NNM this(%v) Not Equal that(%v)", this.NNM, that1.NNM) + } + if !this.NM.Equal(that1.NM) { + return fmt.Errorf("NM this(%v) Not Equal that(%v)", this.NM, that1.NM) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.EnumField != nil && that1.EnumField != nil { + if *this.EnumField != *that1.EnumField { + return false + } + } else if this.EnumField != nil { + return false + } else if that1.EnumField != nil { + return false + } + if !this.NNM.Equal(that1.NNM) { + return false + } + if !this.NM.Equal(that1.NM) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition_NestedMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition_NestedMessage) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition_NestedMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition_NestedMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinition_NestedMessagebut is not nil && this == nil") + } + if this.NestedField1 != nil && that1.NestedField1 != nil { + if *this.NestedField1 != *that1.NestedField1 { + return fmt.Errorf("NestedField1 this(%v) Not Equal that(%v)", *this.NestedField1, *that1.NestedField1) + } + } else if this.NestedField1 != nil { + return fmt.Errorf("this.NestedField1 == nil && that.NestedField1 != nil") + } else if that1.NestedField1 != nil { + return fmt.Errorf("NestedField1 this(%v) Not Equal that(%v)", this.NestedField1, that1.NestedField1) + } + if !this.NNM.Equal(that1.NNM) { + return fmt.Errorf("NNM this(%v) Not Equal that(%v)", this.NNM, that1.NNM) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition_NestedMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition_NestedMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.NestedField1 != nil && that1.NestedField1 != nil { + if *this.NestedField1 != *that1.NestedField1 { + return false + } + } else if this.NestedField1 != nil { + return false + } else if that1.NestedField1 != nil { + return false + } + if !this.NNM.Equal(that1.NNM) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition_NestedMessage_NestedNestedMsg) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition_NestedMessage_NestedNestedMsg") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition_NestedMessage_NestedNestedMsg but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinition_NestedMessage_NestedNestedMsgbut is not nil && this == nil") + } + if this.NestedNestedField1 != nil && that1.NestedNestedField1 != nil { + if *this.NestedNestedField1 != *that1.NestedNestedField1 { + return fmt.Errorf("NestedNestedField1 this(%v) Not Equal that(%v)", *this.NestedNestedField1, *that1.NestedNestedField1) + } + } else if this.NestedNestedField1 != nil { + return fmt.Errorf("this.NestedNestedField1 == nil && that.NestedNestedField1 != nil") + } else if that1.NestedNestedField1 != nil { + return fmt.Errorf("NestedNestedField1 this(%v) Not Equal that(%v)", this.NestedNestedField1, that1.NestedNestedField1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition_NestedMessage_NestedNestedMsg) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.NestedNestedField1 != nil && that1.NestedNestedField1 != nil { + if *this.NestedNestedField1 != *that1.NestedNestedField1 { + return false + } + } else if this.NestedNestedField1 != nil { + return false + } else if that1.NestedNestedField1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedScope) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedScope) + if !ok { + return fmt.Errorf("that is not of type *NestedScope") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedScope but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedScopebut is not nil && this == nil") + } + if !this.A.Equal(that1.A) { + return fmt.Errorf("A this(%v) Not Equal that(%v)", this.A, that1.A) + } + if this.B != nil && that1.B != nil { + if *this.B != *that1.B { + return fmt.Errorf("B this(%v) Not Equal that(%v)", *this.B, *that1.B) + } + } else if this.B != nil { + return fmt.Errorf("this.B == nil && that.B != nil") + } else if that1.B != nil { + return fmt.Errorf("B this(%v) Not Equal that(%v)", this.B, that1.B) + } + if !this.C.Equal(that1.C) { + return fmt.Errorf("C this(%v) Not Equal that(%v)", this.C, that1.C) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedScope) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedScope) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.A.Equal(that1.A) { + return false + } + if this.B != nil && that1.B != nil { + if *this.B != *that1.B { + return false + } + } else if this.B != nil { + return false + } else if that1.B != nil { + return false + } + if !this.C.Equal(that1.C) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNativeDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNativeDefault) + if !ok { + return fmt.Errorf("that is not of type *NinOptNativeDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNativeDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativeDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", *this.Field8, *that1.Field8) + } + } else if this.Field8 != nil { + return fmt.Errorf("this.Field8 == nil && that.Field8 != nil") + } else if that1.Field8 != nil { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", *this.Field9, *that1.Field9) + } + } else if this.Field9 != nil { + return fmt.Errorf("this.Field9 == nil && that.Field9 != nil") + } else if that1.Field9 != nil { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", *this.Field10, *that1.Field10) + } + } else if this.Field10 != nil { + return fmt.Errorf("this.Field10 == nil && that.Field10 != nil") + } else if that1.Field10 != nil { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", *this.Field11, *that1.Field11) + } + } else if this.Field11 != nil { + return fmt.Errorf("this.Field11 == nil && that.Field11 != nil") + } else if that1.Field11 != nil { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", *this.Field12, *that1.Field12) + } + } else if this.Field12 != nil { + return fmt.Errorf("this.Field12 == nil && that.Field12 != nil") + } else if that1.Field12 != nil { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNativeDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNativeDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return false + } + } else if this.Field8 != nil { + return false + } else if that1.Field8 != nil { + return false + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return false + } + } else if this.Field9 != nil { + return false + } else if that1.Field9 != nil { + return false + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return false + } + } else if this.Field10 != nil { + return false + } else if that1.Field10 != nil { + return false + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return false + } + } else if this.Field11 != nil { + return false + } else if that1.Field11 != nil { + return false + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return false + } + } else if this.Field12 != nil { + return false + } else if that1.Field12 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomContainer) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomContainer) + if !ok { + return fmt.Errorf("that is not of type *CustomContainer") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomContainer but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomContainerbut is not nil && this == nil") + } + if !this.CustomStruct.Equal(&that1.CustomStruct) { + return fmt.Errorf("CustomStruct this(%v) Not Equal that(%v)", this.CustomStruct, that1.CustomStruct) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomContainer) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomContainer) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.CustomStruct.Equal(&that1.CustomStruct) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNidOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNidOptNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNidOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNidOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNidOptNativebut is not nil && this == nil") + } + if this.FieldA != that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if this.FieldC != that1.FieldC { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if this.FieldD != that1.FieldD { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", this.FieldD, that1.FieldD) + } + if this.FieldE != that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if this.FieldG != that1.FieldG { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if this.FieldJ != that1.FieldJ { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if this.FieldK != that1.FieldK { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", this.FieldK, that1.FieldK) + } + if this.FieldL != that1.FieldL { + return fmt.Errorf("FieldL this(%v) Not Equal that(%v)", this.FieldL, that1.FieldL) + } + if this.FieldM != that1.FieldM { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", this.FieldM, that1.FieldM) + } + if this.FieldN != that1.FieldN { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", this.FieldN, that1.FieldN) + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", this.FieldO, that1.FieldO) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNidOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNidOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != that1.FieldA { + return false + } + if this.FieldB != that1.FieldB { + return false + } + if this.FieldC != that1.FieldC { + return false + } + if this.FieldD != that1.FieldD { + return false + } + if this.FieldE != that1.FieldE { + return false + } + if this.FieldF != that1.FieldF { + return false + } + if this.FieldG != that1.FieldG { + return false + } + if this.FieldH != that1.FieldH { + return false + } + if this.FieldI != that1.FieldI { + return false + } + if this.FieldJ != that1.FieldJ { + return false + } + if this.FieldK != that1.FieldK { + return false + } + if this.FieldL != that1.FieldL { + return false + } + if this.FieldM != that1.FieldM { + return false + } + if this.FieldN != that1.FieldN { + return false + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinOptNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinOptNativebut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if this.FieldC != nil && that1.FieldC != nil { + if *this.FieldC != *that1.FieldC { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", *this.FieldC, *that1.FieldC) + } + } else if this.FieldC != nil { + return fmt.Errorf("this.FieldC == nil && that.FieldC != nil") + } else if that1.FieldC != nil { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if this.FieldD != nil && that1.FieldD != nil { + if *this.FieldD != *that1.FieldD { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", *this.FieldD, *that1.FieldD) + } + } else if this.FieldD != nil { + return fmt.Errorf("this.FieldD == nil && that.FieldD != nil") + } else if that1.FieldD != nil { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", this.FieldD, that1.FieldD) + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", *this.FieldE, *that1.FieldE) + } + } else if this.FieldE != nil { + return fmt.Errorf("this.FieldE == nil && that.FieldE != nil") + } else if that1.FieldE != nil { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", *this.FieldF, *that1.FieldF) + } + } else if this.FieldF != nil { + return fmt.Errorf("this.FieldF == nil && that.FieldF != nil") + } else if that1.FieldF != nil { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if this.FieldG != nil && that1.FieldG != nil { + if *this.FieldG != *that1.FieldG { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", *this.FieldG, *that1.FieldG) + } + } else if this.FieldG != nil { + return fmt.Errorf("this.FieldG == nil && that.FieldG != nil") + } else if that1.FieldG != nil { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", *this.FieldH, *that1.FieldH) + } + } else if this.FieldH != nil { + return fmt.Errorf("this.FieldH == nil && that.FieldH != nil") + } else if that1.FieldH != nil { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", *this.FieldI, *that1.FieldI) + } + } else if this.FieldI != nil { + return fmt.Errorf("this.FieldI == nil && that.FieldI != nil") + } else if that1.FieldI != nil { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if this.FieldJ != nil && that1.FieldJ != nil { + if *this.FieldJ != *that1.FieldJ { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", *this.FieldJ, *that1.FieldJ) + } + } else if this.FieldJ != nil { + return fmt.Errorf("this.FieldJ == nil && that.FieldJ != nil") + } else if that1.FieldJ != nil { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if this.FieldK != nil && that1.FieldK != nil { + if *this.FieldK != *that1.FieldK { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", *this.FieldK, *that1.FieldK) + } + } else if this.FieldK != nil { + return fmt.Errorf("this.FieldK == nil && that.FieldK != nil") + } else if that1.FieldK != nil { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", this.FieldK, that1.FieldK) + } + if this.FielL != nil && that1.FielL != nil { + if *this.FielL != *that1.FielL { + return fmt.Errorf("FielL this(%v) Not Equal that(%v)", *this.FielL, *that1.FielL) + } + } else if this.FielL != nil { + return fmt.Errorf("this.FielL == nil && that.FielL != nil") + } else if that1.FielL != nil { + return fmt.Errorf("FielL this(%v) Not Equal that(%v)", this.FielL, that1.FielL) + } + if this.FieldM != nil && that1.FieldM != nil { + if *this.FieldM != *that1.FieldM { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", *this.FieldM, *that1.FieldM) + } + } else if this.FieldM != nil { + return fmt.Errorf("this.FieldM == nil && that.FieldM != nil") + } else if that1.FieldM != nil { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", this.FieldM, that1.FieldM) + } + if this.FieldN != nil && that1.FieldN != nil { + if *this.FieldN != *that1.FieldN { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", *this.FieldN, *that1.FieldN) + } + } else if this.FieldN != nil { + return fmt.Errorf("this.FieldN == nil && that.FieldN != nil") + } else if that1.FieldN != nil { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", this.FieldN, that1.FieldN) + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", this.FieldO, that1.FieldO) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if this.FieldC != nil && that1.FieldC != nil { + if *this.FieldC != *that1.FieldC { + return false + } + } else if this.FieldC != nil { + return false + } else if that1.FieldC != nil { + return false + } + if this.FieldD != nil && that1.FieldD != nil { + if *this.FieldD != *that1.FieldD { + return false + } + } else if this.FieldD != nil { + return false + } else if that1.FieldD != nil { + return false + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return false + } + } else if this.FieldE != nil { + return false + } else if that1.FieldE != nil { + return false + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return false + } + } else if this.FieldF != nil { + return false + } else if that1.FieldF != nil { + return false + } + if this.FieldG != nil && that1.FieldG != nil { + if *this.FieldG != *that1.FieldG { + return false + } + } else if this.FieldG != nil { + return false + } else if that1.FieldG != nil { + return false + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return false + } + } else if this.FieldH != nil { + return false + } else if that1.FieldH != nil { + return false + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return false + } + } else if this.FieldI != nil { + return false + } else if that1.FieldI != nil { + return false + } + if this.FieldJ != nil && that1.FieldJ != nil { + if *this.FieldJ != *that1.FieldJ { + return false + } + } else if this.FieldJ != nil { + return false + } else if that1.FieldJ != nil { + return false + } + if this.FieldK != nil && that1.FieldK != nil { + if *this.FieldK != *that1.FieldK { + return false + } + } else if this.FieldK != nil { + return false + } else if that1.FieldK != nil { + return false + } + if this.FielL != nil && that1.FielL != nil { + if *this.FielL != *that1.FielL { + return false + } + } else if this.FielL != nil { + return false + } else if that1.FielL != nil { + return false + } + if this.FieldM != nil && that1.FieldM != nil { + if *this.FieldM != *that1.FieldM { + return false + } + } else if this.FieldM != nil { + return false + } else if that1.FieldM != nil { + return false + } + if this.FieldN != nil && that1.FieldN != nil { + if *this.FieldN != *that1.FieldN { + return false + } + } else if this.FieldN != nil { + return false + } else if that1.FieldN != nil { + return false + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinRepNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinRepNativebut is not nil && this == nil") + } + if len(this.FieldA) != len(that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", len(this.FieldA), len(that1.FieldA)) + } + for i := range this.FieldA { + if this.FieldA[i] != that1.FieldA[i] { + return fmt.Errorf("FieldA this[%v](%v) Not Equal that[%v](%v)", i, this.FieldA[i], i, that1.FieldA[i]) + } + } + if len(this.FieldB) != len(that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", len(this.FieldB), len(that1.FieldB)) + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return fmt.Errorf("FieldB this[%v](%v) Not Equal that[%v](%v)", i, this.FieldB[i], i, that1.FieldB[i]) + } + } + if len(this.FieldC) != len(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", len(this.FieldC), len(that1.FieldC)) + } + for i := range this.FieldC { + if this.FieldC[i] != that1.FieldC[i] { + return fmt.Errorf("FieldC this[%v](%v) Not Equal that[%v](%v)", i, this.FieldC[i], i, that1.FieldC[i]) + } + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if this.FieldD[i] != that1.FieldD[i] { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if len(this.FieldE) != len(that1.FieldE) { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", len(this.FieldE), len(that1.FieldE)) + } + for i := range this.FieldE { + if this.FieldE[i] != that1.FieldE[i] { + return fmt.Errorf("FieldE this[%v](%v) Not Equal that[%v](%v)", i, this.FieldE[i], i, that1.FieldE[i]) + } + } + if len(this.FieldF) != len(that1.FieldF) { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", len(this.FieldF), len(that1.FieldF)) + } + for i := range this.FieldF { + if this.FieldF[i] != that1.FieldF[i] { + return fmt.Errorf("FieldF this[%v](%v) Not Equal that[%v](%v)", i, this.FieldF[i], i, that1.FieldF[i]) + } + } + if len(this.FieldG) != len(that1.FieldG) { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", len(this.FieldG), len(that1.FieldG)) + } + for i := range this.FieldG { + if this.FieldG[i] != that1.FieldG[i] { + return fmt.Errorf("FieldG this[%v](%v) Not Equal that[%v](%v)", i, this.FieldG[i], i, that1.FieldG[i]) + } + } + if len(this.FieldH) != len(that1.FieldH) { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", len(this.FieldH), len(that1.FieldH)) + } + for i := range this.FieldH { + if this.FieldH[i] != that1.FieldH[i] { + return fmt.Errorf("FieldH this[%v](%v) Not Equal that[%v](%v)", i, this.FieldH[i], i, that1.FieldH[i]) + } + } + if len(this.FieldI) != len(that1.FieldI) { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", len(this.FieldI), len(that1.FieldI)) + } + for i := range this.FieldI { + if this.FieldI[i] != that1.FieldI[i] { + return fmt.Errorf("FieldI this[%v](%v) Not Equal that[%v](%v)", i, this.FieldI[i], i, that1.FieldI[i]) + } + } + if len(this.FieldJ) != len(that1.FieldJ) { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", len(this.FieldJ), len(that1.FieldJ)) + } + for i := range this.FieldJ { + if this.FieldJ[i] != that1.FieldJ[i] { + return fmt.Errorf("FieldJ this[%v](%v) Not Equal that[%v](%v)", i, this.FieldJ[i], i, that1.FieldJ[i]) + } + } + if len(this.FieldK) != len(that1.FieldK) { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", len(this.FieldK), len(that1.FieldK)) + } + for i := range this.FieldK { + if this.FieldK[i] != that1.FieldK[i] { + return fmt.Errorf("FieldK this[%v](%v) Not Equal that[%v](%v)", i, this.FieldK[i], i, that1.FieldK[i]) + } + } + if len(this.FieldL) != len(that1.FieldL) { + return fmt.Errorf("FieldL this(%v) Not Equal that(%v)", len(this.FieldL), len(that1.FieldL)) + } + for i := range this.FieldL { + if this.FieldL[i] != that1.FieldL[i] { + return fmt.Errorf("FieldL this[%v](%v) Not Equal that[%v](%v)", i, this.FieldL[i], i, that1.FieldL[i]) + } + } + if len(this.FieldM) != len(that1.FieldM) { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", len(this.FieldM), len(that1.FieldM)) + } + for i := range this.FieldM { + if this.FieldM[i] != that1.FieldM[i] { + return fmt.Errorf("FieldM this[%v](%v) Not Equal that[%v](%v)", i, this.FieldM[i], i, that1.FieldM[i]) + } + } + if len(this.FieldN) != len(that1.FieldN) { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", len(this.FieldN), len(that1.FieldN)) + } + for i := range this.FieldN { + if this.FieldN[i] != that1.FieldN[i] { + return fmt.Errorf("FieldN this[%v](%v) Not Equal that[%v](%v)", i, this.FieldN[i], i, that1.FieldN[i]) + } + } + if len(this.FieldO) != len(that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", len(this.FieldO), len(that1.FieldO)) + } + for i := range this.FieldO { + if !bytes.Equal(this.FieldO[i], that1.FieldO[i]) { + return fmt.Errorf("FieldO this[%v](%v) Not Equal that[%v](%v)", i, this.FieldO[i], i, that1.FieldO[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.FieldA) != len(that1.FieldA) { + return false + } + for i := range this.FieldA { + if this.FieldA[i] != that1.FieldA[i] { + return false + } + } + if len(this.FieldB) != len(that1.FieldB) { + return false + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return false + } + } + if len(this.FieldC) != len(that1.FieldC) { + return false + } + for i := range this.FieldC { + if this.FieldC[i] != that1.FieldC[i] { + return false + } + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if this.FieldD[i] != that1.FieldD[i] { + return false + } + } + if len(this.FieldE) != len(that1.FieldE) { + return false + } + for i := range this.FieldE { + if this.FieldE[i] != that1.FieldE[i] { + return false + } + } + if len(this.FieldF) != len(that1.FieldF) { + return false + } + for i := range this.FieldF { + if this.FieldF[i] != that1.FieldF[i] { + return false + } + } + if len(this.FieldG) != len(that1.FieldG) { + return false + } + for i := range this.FieldG { + if this.FieldG[i] != that1.FieldG[i] { + return false + } + } + if len(this.FieldH) != len(that1.FieldH) { + return false + } + for i := range this.FieldH { + if this.FieldH[i] != that1.FieldH[i] { + return false + } + } + if len(this.FieldI) != len(that1.FieldI) { + return false + } + for i := range this.FieldI { + if this.FieldI[i] != that1.FieldI[i] { + return false + } + } + if len(this.FieldJ) != len(that1.FieldJ) { + return false + } + for i := range this.FieldJ { + if this.FieldJ[i] != that1.FieldJ[i] { + return false + } + } + if len(this.FieldK) != len(that1.FieldK) { + return false + } + for i := range this.FieldK { + if this.FieldK[i] != that1.FieldK[i] { + return false + } + } + if len(this.FieldL) != len(that1.FieldL) { + return false + } + for i := range this.FieldL { + if this.FieldL[i] != that1.FieldL[i] { + return false + } + } + if len(this.FieldM) != len(that1.FieldM) { + return false + } + for i := range this.FieldM { + if this.FieldM[i] != that1.FieldM[i] { + return false + } + } + if len(this.FieldN) != len(that1.FieldN) { + return false + } + for i := range this.FieldN { + if this.FieldN[i] != that1.FieldN[i] { + return false + } + } + if len(this.FieldO) != len(that1.FieldO) { + return false + } + for i := range this.FieldO { + if !bytes.Equal(this.FieldO[i], that1.FieldO[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinStruct) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinStructbut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if !this.FieldC.Equal(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", *this.FieldE, *that1.FieldE) + } + } else if this.FieldE != nil { + return fmt.Errorf("this.FieldE == nil && that.FieldE != nil") + } else if that1.FieldE != nil { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", *this.FieldF, *that1.FieldF) + } + } else if this.FieldF != nil { + return fmt.Errorf("this.FieldF == nil && that.FieldF != nil") + } else if that1.FieldF != nil { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if !this.FieldG.Equal(that1.FieldG) { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", *this.FieldH, *that1.FieldH) + } + } else if this.FieldH != nil { + return fmt.Errorf("this.FieldH == nil && that.FieldH != nil") + } else if that1.FieldH != nil { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", *this.FieldI, *that1.FieldI) + } + } else if this.FieldI != nil { + return fmt.Errorf("this.FieldI == nil && that.FieldI != nil") + } else if that1.FieldI != nil { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if !bytes.Equal(this.FieldJ, that1.FieldJ) { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if !this.FieldC.Equal(that1.FieldC) { + return false + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return false + } + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return false + } + } else if this.FieldE != nil { + return false + } else if that1.FieldE != nil { + return false + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return false + } + } else if this.FieldF != nil { + return false + } else if that1.FieldF != nil { + return false + } + if !this.FieldG.Equal(that1.FieldG) { + return false + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return false + } + } else if this.FieldH != nil { + return false + } else if that1.FieldH != nil { + return false + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return false + } + } else if this.FieldI != nil { + return false + } else if that1.FieldI != nil { + return false + } + if !bytes.Equal(this.FieldJ, that1.FieldJ) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameCustomType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameCustomType) + if !ok { + return fmt.Errorf("that is not of type *CustomNameCustomType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameCustomType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameCustomTypebut is not nil && this == nil") + } + if that1.FieldA == nil { + if this.FieldA != nil { + return fmt.Errorf("this.FieldA != nil && that1.FieldA == nil") + } + } else if !this.FieldA.Equal(*that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if that1.FieldB == nil { + if this.FieldB != nil { + return fmt.Errorf("this.FieldB != nil && that1.FieldB == nil") + } + } else if !this.FieldB.Equal(*that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if len(this.FieldC) != len(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", len(this.FieldC), len(that1.FieldC)) + } + for i := range this.FieldC { + if !this.FieldC[i].Equal(that1.FieldC[i]) { + return fmt.Errorf("FieldC this[%v](%v) Not Equal that[%v](%v)", i, this.FieldC[i], i, that1.FieldC[i]) + } + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameCustomType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameCustomType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.FieldA == nil { + if this.FieldA != nil { + return false + } + } else if !this.FieldA.Equal(*that1.FieldA) { + return false + } + if that1.FieldB == nil { + if this.FieldB != nil { + return false + } + } else if !this.FieldB.Equal(*that1.FieldB) { + return false + } + if len(this.FieldC) != len(that1.FieldC) { + return false + } + for i := range this.FieldC { + if !this.FieldC[i].Equal(that1.FieldC[i]) { + return false + } + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinEmbeddedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinEmbeddedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinEmbeddedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinEmbeddedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinEmbeddedStructUnionbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.FieldA.Equal(that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinEmbeddedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinEmbeddedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.FieldA.Equal(that1.FieldA) { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameEnum) + if !ok { + return fmt.Errorf("that is not of type *CustomNameEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameEnumbut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if len(this.FieldB) != len(that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", len(this.FieldB), len(that1.FieldB)) + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return fmt.Errorf("FieldB this[%v](%v) Not Equal that[%v](%v)", i, this.FieldB[i], i, that1.FieldB[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if len(this.FieldB) != len(that1.FieldB) { + return false + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NoExtensionsMap) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NoExtensionsMap) + if !ok { + return fmt.Errorf("that is not of type *NoExtensionsMap") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NoExtensionsMap but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NoExtensionsMapbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) { + return fmt.Errorf("XXX_extensions this(%v) Not Equal that(%v)", this.XXX_extensions, that1.XXX_extensions) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NoExtensionsMap) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NoExtensionsMap) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Unrecognized) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Unrecognized) + if !ok { + return fmt.Errorf("that is not of type *Unrecognized") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Unrecognized but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Unrecognizedbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *Unrecognized) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Unrecognized) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} +func (this *UnrecognizedWithInner) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithInner) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithInner") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithInner but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithInnerbut is not nil && this == nil") + } + if len(this.Embedded) != len(that1.Embedded) { + return fmt.Errorf("Embedded this(%v) Not Equal that(%v)", len(this.Embedded), len(that1.Embedded)) + } + for i := range this.Embedded { + if !this.Embedded[i].Equal(that1.Embedded[i]) { + return fmt.Errorf("Embedded this[%v](%v) Not Equal that[%v](%v)", i, this.Embedded[i], i, that1.Embedded[i]) + } + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *UnrecognizedWithInner) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithInner) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Embedded) != len(that1.Embedded) { + return false + } + for i := range this.Embedded { + if !this.Embedded[i].Equal(that1.Embedded[i]) { + return false + } + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *UnrecognizedWithInner_Inner) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithInner_Inner) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithInner_Inner") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithInner_Inner but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithInner_Innerbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *UnrecognizedWithInner_Inner) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithInner_Inner) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} +func (this *UnrecognizedWithEmbed) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithEmbed) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithEmbed") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithEmbed but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithEmbedbut is not nil && this == nil") + } + if !this.UnrecognizedWithEmbed_Embedded.Equal(&that1.UnrecognizedWithEmbed_Embedded) { + return fmt.Errorf("UnrecognizedWithEmbed_Embedded this(%v) Not Equal that(%v)", this.UnrecognizedWithEmbed_Embedded, that1.UnrecognizedWithEmbed_Embedded) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *UnrecognizedWithEmbed) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithEmbed) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.UnrecognizedWithEmbed_Embedded.Equal(&that1.UnrecognizedWithEmbed_Embedded) { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *UnrecognizedWithEmbed_Embedded) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithEmbed_Embedded) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithEmbed_Embedded") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithEmbed_Embedded but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithEmbed_Embeddedbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *UnrecognizedWithEmbed_Embedded) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithEmbed_Embedded) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} + +type NidOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() float64 + GetField2() float32 + GetField3() int32 + GetField4() int64 + GetField5() uint32 + GetField6() uint64 + GetField7() int32 + GetField8() int64 + GetField9() uint32 + GetField10() int32 + GetField11() uint64 + GetField12() int64 + GetField13() bool + GetField14() string + GetField15() []byte +} + +func (this *NidOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptNativeFromFace(this) +} + +func (this *NidOptNative) GetField1() float64 { + return this.Field1 +} + +func (this *NidOptNative) GetField2() float32 { + return this.Field2 +} + +func (this *NidOptNative) GetField3() int32 { + return this.Field3 +} + +func (this *NidOptNative) GetField4() int64 { + return this.Field4 +} + +func (this *NidOptNative) GetField5() uint32 { + return this.Field5 +} + +func (this *NidOptNative) GetField6() uint64 { + return this.Field6 +} + +func (this *NidOptNative) GetField7() int32 { + return this.Field7 +} + +func (this *NidOptNative) GetField8() int64 { + return this.Field8 +} + +func (this *NidOptNative) GetField9() uint32 { + return this.Field9 +} + +func (this *NidOptNative) GetField10() int32 { + return this.Field10 +} + +func (this *NidOptNative) GetField11() uint64 { + return this.Field11 +} + +func (this *NidOptNative) GetField12() int64 { + return this.Field12 +} + +func (this *NidOptNative) GetField13() bool { + return this.Field13 +} + +func (this *NidOptNative) GetField14() string { + return this.Field14 +} + +func (this *NidOptNative) GetField15() []byte { + return this.Field15 +} + +func NewNidOptNativeFromFace(that NidOptNativeFace) *NidOptNative { + this := &NidOptNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *int32 + GetField4() *int64 + GetField5() *uint32 + GetField6() *uint64 + GetField7() *int32 + GetField8() *int64 + GetField9() *uint32 + GetField10() *int32 + GetField11() *uint64 + GetField12() *int64 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptNativeFromFace(this) +} + +func (this *NinOptNative) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptNative) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptNative) GetField3() *int32 { + return this.Field3 +} + +func (this *NinOptNative) GetField4() *int64 { + return this.Field4 +} + +func (this *NinOptNative) GetField5() *uint32 { + return this.Field5 +} + +func (this *NinOptNative) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptNative) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptNative) GetField8() *int64 { + return this.Field8 +} + +func (this *NinOptNative) GetField9() *uint32 { + return this.Field9 +} + +func (this *NinOptNative) GetField10() *int32 { + return this.Field10 +} + +func (this *NinOptNative) GetField11() *uint64 { + return this.Field11 +} + +func (this *NinOptNative) GetField12() *int64 { + return this.Field12 +} + +func (this *NinOptNative) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptNative) GetField14() *string { + return this.Field14 +} + +func (this *NinOptNative) GetField15() []byte { + return this.Field15 +} + +func NewNinOptNativeFromFace(that NinOptNativeFace) *NinOptNative { + this := &NinOptNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NidRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepNativeFromFace(this) +} + +func (this *NidRepNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NidRepNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NidRepNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NidRepNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NidRepNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NidRepNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NidRepNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NidRepNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NidRepNative) GetField13() []bool { + return this.Field13 +} + +func (this *NidRepNative) GetField14() []string { + return this.Field14 +} + +func (this *NidRepNative) GetField15() [][]byte { + return this.Field15 +} + +func NewNidRepNativeFromFace(that NidRepNativeFace) *NidRepNative { + this := &NidRepNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NinRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepNativeFromFace(this) +} + +func (this *NinRepNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NinRepNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NinRepNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NinRepNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NinRepNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NinRepNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NinRepNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NinRepNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NinRepNative) GetField13() []bool { + return this.Field13 +} + +func (this *NinRepNative) GetField14() []string { + return this.Field14 +} + +func (this *NinRepNative) GetField15() [][]byte { + return this.Field15 +} + +func NewNinRepNativeFromFace(that NinRepNativeFace) *NinRepNative { + this := &NinRepNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepPackedNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool +} + +func (this *NidRepPackedNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepPackedNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepPackedNativeFromFace(this) +} + +func (this *NidRepPackedNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepPackedNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepPackedNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NidRepPackedNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NidRepPackedNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NidRepPackedNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepPackedNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepPackedNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NidRepPackedNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NidRepPackedNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NidRepPackedNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NidRepPackedNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NidRepPackedNative) GetField13() []bool { + return this.Field13 +} + +func NewNidRepPackedNativeFromFace(that NidRepPackedNativeFace) *NidRepPackedNative { + this := &NidRepPackedNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + return this +} + +type NinRepPackedNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool +} + +func (this *NinRepPackedNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepPackedNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepPackedNativeFromFace(this) +} + +func (this *NinRepPackedNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepPackedNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepPackedNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NinRepPackedNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NinRepPackedNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NinRepPackedNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepPackedNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepPackedNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NinRepPackedNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NinRepPackedNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NinRepPackedNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NinRepPackedNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NinRepPackedNative) GetField13() []bool { + return this.Field13 +} + +func NewNinRepPackedNativeFromFace(that NinRepPackedNativeFace) *NinRepPackedNative { + this := &NinRepPackedNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + return this +} + +type NidOptStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() float64 + GetField2() float32 + GetField3() NidOptNative + GetField4() NinOptNative + GetField6() uint64 + GetField7() int32 + GetField8() NidOptNative + GetField13() bool + GetField14() string + GetField15() []byte +} + +func (this *NidOptStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptStructFromFace(this) +} + +func (this *NidOptStruct) GetField1() float64 { + return this.Field1 +} + +func (this *NidOptStruct) GetField2() float32 { + return this.Field2 +} + +func (this *NidOptStruct) GetField3() NidOptNative { + return this.Field3 +} + +func (this *NidOptStruct) GetField4() NinOptNative { + return this.Field4 +} + +func (this *NidOptStruct) GetField6() uint64 { + return this.Field6 +} + +func (this *NidOptStruct) GetField7() int32 { + return this.Field7 +} + +func (this *NidOptStruct) GetField8() NidOptNative { + return this.Field8 +} + +func (this *NidOptStruct) GetField13() bool { + return this.Field13 +} + +func (this *NidOptStruct) GetField14() string { + return this.Field14 +} + +func (this *NidOptStruct) GetField15() []byte { + return this.Field15 +} + +func NewNidOptStructFromFace(that NidOptStructFace) *NidOptStruct { + this := &NidOptStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *NidOptNative + GetField4() *NinOptNative + GetField6() *uint64 + GetField7() *int32 + GetField8() *NidOptNative + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptStructFromFace(this) +} + +func (this *NinOptStruct) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptStruct) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptStruct) GetField3() *NidOptNative { + return this.Field3 +} + +func (this *NinOptStruct) GetField4() *NinOptNative { + return this.Field4 +} + +func (this *NinOptStruct) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptStruct) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptStruct) GetField8() *NidOptNative { + return this.Field8 +} + +func (this *NinOptStruct) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptStruct) GetField14() *string { + return this.Field14 +} + +func (this *NinOptStruct) GetField15() []byte { + return this.Field15 +} + +func NewNinOptStructFromFace(that NinOptStructFace) *NinOptStruct { + this := &NinOptStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []NidOptNative + GetField4() []NinOptNative + GetField6() []uint64 + GetField7() []int32 + GetField8() []NidOptNative + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NidRepStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepStructFromFace(this) +} + +func (this *NidRepStruct) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepStruct) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepStruct) GetField3() []NidOptNative { + return this.Field3 +} + +func (this *NidRepStruct) GetField4() []NinOptNative { + return this.Field4 +} + +func (this *NidRepStruct) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepStruct) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepStruct) GetField8() []NidOptNative { + return this.Field8 +} + +func (this *NidRepStruct) GetField13() []bool { + return this.Field13 +} + +func (this *NidRepStruct) GetField14() []string { + return this.Field14 +} + +func (this *NidRepStruct) GetField15() [][]byte { + return this.Field15 +} + +func NewNidRepStructFromFace(that NidRepStructFace) *NidRepStruct { + this := &NidRepStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinRepStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []*NidOptNative + GetField4() []*NinOptNative + GetField6() []uint64 + GetField7() []int32 + GetField8() []*NidOptNative + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NinRepStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepStructFromFace(this) +} + +func (this *NinRepStruct) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepStruct) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepStruct) GetField3() []*NidOptNative { + return this.Field3 +} + +func (this *NinRepStruct) GetField4() []*NinOptNative { + return this.Field4 +} + +func (this *NinRepStruct) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepStruct) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepStruct) GetField8() []*NidOptNative { + return this.Field8 +} + +func (this *NinRepStruct) GetField13() []bool { + return this.Field13 +} + +func (this *NinRepStruct) GetField14() []string { + return this.Field14 +} + +func (this *NinRepStruct) GetField15() [][]byte { + return this.Field15 +} + +func NewNinRepStructFromFace(that NinRepStructFace) *NinRepStruct { + this := &NinRepStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidEmbeddedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() NidOptNative + GetField210() bool +} + +func (this *NidEmbeddedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidEmbeddedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidEmbeddedStructFromFace(this) +} + +func (this *NidEmbeddedStruct) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NidEmbeddedStruct) GetField200() NidOptNative { + return this.Field200 +} + +func (this *NidEmbeddedStruct) GetField210() bool { + return this.Field210 +} + +func NewNidEmbeddedStructFromFace(that NidEmbeddedStructFace) *NidEmbeddedStruct { + this := &NidEmbeddedStruct{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NinEmbeddedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() *NidOptNative + GetField210() *bool +} + +func (this *NinEmbeddedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinEmbeddedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinEmbeddedStructFromFace(this) +} + +func (this *NinEmbeddedStruct) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NinEmbeddedStruct) GetField200() *NidOptNative { + return this.Field200 +} + +func (this *NinEmbeddedStruct) GetField210() *bool { + return this.Field210 +} + +func NewNinEmbeddedStructFromFace(that NinEmbeddedStructFace) *NinEmbeddedStruct { + this := &NinEmbeddedStruct{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NidNestedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() NidOptStruct + GetField2() []NidRepStruct +} + +func (this *NidNestedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidNestedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidNestedStructFromFace(this) +} + +func (this *NidNestedStruct) GetField1() NidOptStruct { + return this.Field1 +} + +func (this *NidNestedStruct) GetField2() []NidRepStruct { + return this.Field2 +} + +func NewNidNestedStructFromFace(that NidNestedStructFace) *NidNestedStruct { + this := &NidNestedStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + return this +} + +type NinNestedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *NinOptStruct + GetField2() []*NinRepStruct +} + +func (this *NinNestedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinNestedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinNestedStructFromFace(this) +} + +func (this *NinNestedStruct) GetField1() *NinOptStruct { + return this.Field1 +} + +func (this *NinNestedStruct) GetField2() []*NinRepStruct { + return this.Field2 +} + +func NewNinNestedStructFromFace(that NinNestedStructFace) *NinNestedStruct { + this := &NinNestedStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + return this +} + +type NidOptCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() Uuid + GetValue() github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NidOptCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptCustomFromFace(this) +} + +func (this *NidOptCustom) GetId() Uuid { + return this.Id +} + +func (this *NidOptCustom) GetValue() github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNidOptCustomFromFace(that NidOptCustomFace) *NidOptCustom { + this := &NidOptCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type CustomDashFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetValue() *github_com_gogo_protobuf_test_custom_dash_type.Bytes +} + +func (this *CustomDash) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomDash) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomDashFromFace(this) +} + +func (this *CustomDash) GetValue() *github_com_gogo_protobuf_test_custom_dash_type.Bytes { + return this.Value +} + +func NewCustomDashFromFace(that CustomDashFace) *CustomDash { + this := &CustomDash{} + this.Value = that.GetValue() + return this +} + +type NinOptCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() *Uuid + GetValue() *github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NinOptCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptCustomFromFace(this) +} + +func (this *NinOptCustom) GetId() *Uuid { + return this.Id +} + +func (this *NinOptCustom) GetValue() *github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNinOptCustomFromFace(that NinOptCustomFace) *NinOptCustom { + this := &NinOptCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NidRepCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() []Uuid + GetValue() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NidRepCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepCustomFromFace(this) +} + +func (this *NidRepCustom) GetId() []Uuid { + return this.Id +} + +func (this *NidRepCustom) GetValue() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNidRepCustomFromFace(that NidRepCustomFace) *NidRepCustom { + this := &NidRepCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NinRepCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() []Uuid + GetValue() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NinRepCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepCustomFromFace(this) +} + +func (this *NinRepCustom) GetId() []Uuid { + return this.Id +} + +func (this *NinRepCustom) GetValue() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNinRepCustomFromFace(that NinRepCustomFace) *NinRepCustom { + this := &NinRepCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NinOptNativeUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *int32 + GetField4() *int64 + GetField5() *uint32 + GetField6() *uint64 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptNativeUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptNativeUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptNativeUnionFromFace(this) +} + +func (this *NinOptNativeUnion) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptNativeUnion) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptNativeUnion) GetField3() *int32 { + return this.Field3 +} + +func (this *NinOptNativeUnion) GetField4() *int64 { + return this.Field4 +} + +func (this *NinOptNativeUnion) GetField5() *uint32 { + return this.Field5 +} + +func (this *NinOptNativeUnion) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptNativeUnion) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptNativeUnion) GetField14() *string { + return this.Field14 +} + +func (this *NinOptNativeUnion) GetField15() []byte { + return this.Field15 +} + +func NewNinOptNativeUnionFromFace(that NinOptNativeUnionFace) *NinOptNativeUnion { + this := &NinOptNativeUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *NidOptNative + GetField4() *NinOptNative + GetField6() *uint64 + GetField7() *int32 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptStructUnionFromFace(this) +} + +func (this *NinOptStructUnion) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptStructUnion) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptStructUnion) GetField3() *NidOptNative { + return this.Field3 +} + +func (this *NinOptStructUnion) GetField4() *NinOptNative { + return this.Field4 +} + +func (this *NinOptStructUnion) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptStructUnion) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptStructUnion) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptStructUnion) GetField14() *string { + return this.Field14 +} + +func (this *NinOptStructUnion) GetField15() []byte { + return this.Field15 +} + +func NewNinOptStructUnionFromFace(that NinOptStructUnionFace) *NinOptStructUnion { + this := &NinOptStructUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinEmbeddedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() *NinOptNative + GetField210() *bool +} + +func (this *NinEmbeddedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinEmbeddedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinEmbeddedStructUnionFromFace(this) +} + +func (this *NinEmbeddedStructUnion) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NinEmbeddedStructUnion) GetField200() *NinOptNative { + return this.Field200 +} + +func (this *NinEmbeddedStructUnion) GetField210() *bool { + return this.Field210 +} + +func NewNinEmbeddedStructUnionFromFace(that NinEmbeddedStructUnionFace) *NinEmbeddedStructUnion { + this := &NinEmbeddedStructUnion{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NinNestedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *NinOptNativeUnion + GetField2() *NinOptStructUnion + GetField3() *NinEmbeddedStructUnion +} + +func (this *NinNestedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinNestedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinNestedStructUnionFromFace(this) +} + +func (this *NinNestedStructUnion) GetField1() *NinOptNativeUnion { + return this.Field1 +} + +func (this *NinNestedStructUnion) GetField2() *NinOptStructUnion { + return this.Field2 +} + +func (this *NinNestedStructUnion) GetField3() *NinEmbeddedStructUnion { + return this.Field3 +} + +func NewNinNestedStructUnionFromFace(that NinNestedStructUnionFace) *NinNestedStructUnion { + this := &NinNestedStructUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + return this +} + +type TreeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetOr() *OrBranch + GetAnd() *AndBranch + GetLeaf() *Leaf +} + +func (this *Tree) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Tree) TestProto() github_com_gogo_protobuf_proto.Message { + return NewTreeFromFace(this) +} + +func (this *Tree) GetOr() *OrBranch { + return this.Or +} + +func (this *Tree) GetAnd() *AndBranch { + return this.And +} + +func (this *Tree) GetLeaf() *Leaf { + return this.Leaf +} + +func NewTreeFromFace(that TreeFace) *Tree { + this := &Tree{} + this.Or = that.GetOr() + this.And = that.GetAnd() + this.Leaf = that.GetLeaf() + return this +} + +type OrBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() Tree + GetRight() Tree +} + +func (this *OrBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *OrBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewOrBranchFromFace(this) +} + +func (this *OrBranch) GetLeft() Tree { + return this.Left +} + +func (this *OrBranch) GetRight() Tree { + return this.Right +} + +func NewOrBranchFromFace(that OrBranchFace) *OrBranch { + this := &OrBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type AndBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() Tree + GetRight() Tree +} + +func (this *AndBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AndBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAndBranchFromFace(this) +} + +func (this *AndBranch) GetLeft() Tree { + return this.Left +} + +func (this *AndBranch) GetRight() Tree { + return this.Right +} + +func NewAndBranchFromFace(that AndBranchFace) *AndBranch { + this := &AndBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type LeafFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetValue() int64 + GetStrValue() string +} + +func (this *Leaf) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Leaf) TestProto() github_com_gogo_protobuf_proto.Message { + return NewLeafFromFace(this) +} + +func (this *Leaf) GetValue() int64 { + return this.Value +} + +func (this *Leaf) GetStrValue() string { + return this.StrValue +} + +func NewLeafFromFace(that LeafFace) *Leaf { + this := &Leaf{} + this.Value = that.GetValue() + this.StrValue = that.GetStrValue() + return this +} + +type DeepTreeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetDown() *ADeepBranch + GetAnd() *AndDeepBranch + GetLeaf() *DeepLeaf +} + +func (this *DeepTree) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *DeepTree) TestProto() github_com_gogo_protobuf_proto.Message { + return NewDeepTreeFromFace(this) +} + +func (this *DeepTree) GetDown() *ADeepBranch { + return this.Down +} + +func (this *DeepTree) GetAnd() *AndDeepBranch { + return this.And +} + +func (this *DeepTree) GetLeaf() *DeepLeaf { + return this.Leaf +} + +func NewDeepTreeFromFace(that DeepTreeFace) *DeepTree { + this := &DeepTree{} + this.Down = that.GetDown() + this.And = that.GetAnd() + this.Leaf = that.GetLeaf() + return this +} + +type ADeepBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetDown() DeepTree +} + +func (this *ADeepBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *ADeepBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewADeepBranchFromFace(this) +} + +func (this *ADeepBranch) GetDown() DeepTree { + return this.Down +} + +func NewADeepBranchFromFace(that ADeepBranchFace) *ADeepBranch { + this := &ADeepBranch{} + this.Down = that.GetDown() + return this +} + +type AndDeepBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() DeepTree + GetRight() DeepTree +} + +func (this *AndDeepBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AndDeepBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAndDeepBranchFromFace(this) +} + +func (this *AndDeepBranch) GetLeft() DeepTree { + return this.Left +} + +func (this *AndDeepBranch) GetRight() DeepTree { + return this.Right +} + +func NewAndDeepBranchFromFace(that AndDeepBranchFace) *AndDeepBranch { + this := &AndDeepBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type DeepLeafFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetTree() Tree +} + +func (this *DeepLeaf) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *DeepLeaf) TestProto() github_com_gogo_protobuf_proto.Message { + return NewDeepLeafFromFace(this) +} + +func (this *DeepLeaf) GetTree() Tree { + return this.Tree +} + +func NewDeepLeafFromFace(that DeepLeafFace) *DeepLeaf { + this := &DeepLeaf{} + this.Tree = that.GetTree() + return this +} + +type NilFace interface { + Proto() github_com_gogo_protobuf_proto.Message +} + +func (this *Nil) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Nil) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNilFromFace(this) +} + +func NewNilFromFace(that NilFace) *Nil { + this := &Nil{} + return this +} + +type NidOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() TheTestEnum +} + +func (this *NidOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptEnumFromFace(this) +} + +func (this *NidOptEnum) GetField1() TheTestEnum { + return this.Field1 +} + +func NewNidOptEnumFromFace(that NidOptEnumFace) *NidOptEnum { + this := &NidOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type NinOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *TheTestEnum +} + +func (this *NinOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptEnumFromFace(this) +} + +func (this *NinOptEnum) GetField1() *TheTestEnum { + return this.Field1 +} + +func NewNinOptEnumFromFace(that NinOptEnumFace) *NinOptEnum { + this := &NinOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type NidRepEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []TheTestEnum +} + +func (this *NidRepEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepEnumFromFace(this) +} + +func (this *NidRepEnum) GetField1() []TheTestEnum { + return this.Field1 +} + +func NewNidRepEnumFromFace(that NidRepEnumFace) *NidRepEnum { + this := &NidRepEnum{} + this.Field1 = that.GetField1() + return this +} + +type NinRepEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []TheTestEnum +} + +func (this *NinRepEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepEnumFromFace(this) +} + +func (this *NinRepEnum) GetField1() []TheTestEnum { + return this.Field1 +} + +func NewNinRepEnumFromFace(that NinRepEnumFace) *NinRepEnum { + this := &NinRepEnum{} + this.Field1 = that.GetField1() + return this +} + +type AnotherNinOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *AnotherTestEnum +} + +func (this *AnotherNinOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AnotherNinOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAnotherNinOptEnumFromFace(this) +} + +func (this *AnotherNinOptEnum) GetField1() *AnotherTestEnum { + return this.Field1 +} + +func NewAnotherNinOptEnumFromFace(that AnotherNinOptEnumFace) *AnotherNinOptEnum { + this := &AnotherNinOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type TimerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetTime1() int64 + GetTime2() int64 + GetData() []byte +} + +func (this *Timer) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Timer) TestProto() github_com_gogo_protobuf_proto.Message { + return NewTimerFromFace(this) +} + +func (this *Timer) GetTime1() int64 { + return this.Time1 +} + +func (this *Timer) GetTime2() int64 { + return this.Time2 +} + +func (this *Timer) GetData() []byte { + return this.Data +} + +func NewTimerFromFace(that TimerFace) *Timer { + this := &Timer{} + this.Time1 = that.GetTime1() + this.Time2 = that.GetTime2() + this.Data = that.GetData() + return this +} + +type NestedDefinitionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *int64 + GetEnumField() *NestedDefinition_NestedEnum + GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg + GetNM() *NestedDefinition_NestedMessage +} + +func (this *NestedDefinition) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinitionFromFace(this) +} + +func (this *NestedDefinition) GetField1() *int64 { + return this.Field1 +} + +func (this *NestedDefinition) GetEnumField() *NestedDefinition_NestedEnum { + return this.EnumField +} + +func (this *NestedDefinition) GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.NNM +} + +func (this *NestedDefinition) GetNM() *NestedDefinition_NestedMessage { + return this.NM +} + +func NewNestedDefinitionFromFace(that NestedDefinitionFace) *NestedDefinition { + this := &NestedDefinition{} + this.Field1 = that.GetField1() + this.EnumField = that.GetEnumField() + this.NNM = that.GetNNM() + this.NM = that.GetNM() + return this +} + +type NestedDefinition_NestedMessageFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNestedField1() *uint64 + GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg +} + +func (this *NestedDefinition_NestedMessage) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition_NestedMessage) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinition_NestedMessageFromFace(this) +} + +func (this *NestedDefinition_NestedMessage) GetNestedField1() *uint64 { + return this.NestedField1 +} + +func (this *NestedDefinition_NestedMessage) GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.NNM +} + +func NewNestedDefinition_NestedMessageFromFace(that NestedDefinition_NestedMessageFace) *NestedDefinition_NestedMessage { + this := &NestedDefinition_NestedMessage{} + this.NestedField1 = that.GetNestedField1() + this.NNM = that.GetNNM() + return this +} + +type NestedDefinition_NestedMessage_NestedNestedMsgFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNestedNestedField1() *string +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinition_NestedMessage_NestedNestedMsgFromFace(this) +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) GetNestedNestedField1() *string { + return this.NestedNestedField1 +} + +func NewNestedDefinition_NestedMessage_NestedNestedMsgFromFace(that NestedDefinition_NestedMessage_NestedNestedMsgFace) *NestedDefinition_NestedMessage_NestedNestedMsg { + this := &NestedDefinition_NestedMessage_NestedNestedMsg{} + this.NestedNestedField1 = that.GetNestedNestedField1() + return this +} + +type NestedScopeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetA() *NestedDefinition_NestedMessage_NestedNestedMsg + GetB() *NestedDefinition_NestedEnum + GetC() *NestedDefinition_NestedMessage +} + +func (this *NestedScope) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedScope) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedScopeFromFace(this) +} + +func (this *NestedScope) GetA() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.A +} + +func (this *NestedScope) GetB() *NestedDefinition_NestedEnum { + return this.B +} + +func (this *NestedScope) GetC() *NestedDefinition_NestedMessage { + return this.C +} + +func NewNestedScopeFromFace(that NestedScopeFace) *NestedScope { + this := &NestedScope{} + this.A = that.GetA() + this.B = that.GetB() + this.C = that.GetC() + return this +} + +type CustomContainerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetCustomStruct() NidOptCustom +} + +func (this *CustomContainer) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomContainer) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomContainerFromFace(this) +} + +func (this *CustomContainer) GetCustomStruct() NidOptCustom { + return this.CustomStruct +} + +func NewCustomContainerFromFace(that CustomContainerFace) *CustomContainer { + this := &CustomContainer{} + this.CustomStruct = that.GetCustomStruct() + return this +} + +type CustomNameNidOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() float64 + GetFieldB() float32 + GetFieldC() int32 + GetFieldD() int64 + GetFieldE() uint32 + GetFieldF() uint64 + GetFieldG() int32 + GetFieldH() int64 + GetFieldI() uint32 + GetFieldJ() int32 + GetFieldK() uint64 + GetFieldL() int64 + GetFieldM() bool + GetFieldN() string + GetFieldO() []byte +} + +func (this *CustomNameNidOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNidOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNidOptNativeFromFace(this) +} + +func (this *CustomNameNidOptNative) GetFieldA() float64 { + return this.FieldA +} + +func (this *CustomNameNidOptNative) GetFieldB() float32 { + return this.FieldB +} + +func (this *CustomNameNidOptNative) GetFieldC() int32 { + return this.FieldC +} + +func (this *CustomNameNidOptNative) GetFieldD() int64 { + return this.FieldD +} + +func (this *CustomNameNidOptNative) GetFieldE() uint32 { + return this.FieldE +} + +func (this *CustomNameNidOptNative) GetFieldF() uint64 { + return this.FieldF +} + +func (this *CustomNameNidOptNative) GetFieldG() int32 { + return this.FieldG +} + +func (this *CustomNameNidOptNative) GetFieldH() int64 { + return this.FieldH +} + +func (this *CustomNameNidOptNative) GetFieldI() uint32 { + return this.FieldI +} + +func (this *CustomNameNidOptNative) GetFieldJ() int32 { + return this.FieldJ +} + +func (this *CustomNameNidOptNative) GetFieldK() uint64 { + return this.FieldK +} + +func (this *CustomNameNidOptNative) GetFieldL() int64 { + return this.FieldL +} + +func (this *CustomNameNidOptNative) GetFieldM() bool { + return this.FieldM +} + +func (this *CustomNameNidOptNative) GetFieldN() string { + return this.FieldN +} + +func (this *CustomNameNidOptNative) GetFieldO() []byte { + return this.FieldO +} + +func NewCustomNameNidOptNativeFromFace(that CustomNameNidOptNativeFace) *CustomNameNidOptNative { + this := &CustomNameNidOptNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FieldL = that.GetFieldL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *float64 + GetFieldB() *float32 + GetFieldC() *int32 + GetFieldD() *int64 + GetFieldE() *uint32 + GetFieldF() *uint64 + GetFieldG() *int32 + GetFieldH() *int64 + GetFieldI() *uint32 + GetFieldJ() *int32 + GetFieldK() *uint64 + GetFielL() *int64 + GetFieldM() *bool + GetFieldN() *string + GetFieldO() []byte +} + +func (this *CustomNameNinOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinOptNativeFromFace(this) +} + +func (this *CustomNameNinOptNative) GetFieldA() *float64 { + return this.FieldA +} + +func (this *CustomNameNinOptNative) GetFieldB() *float32 { + return this.FieldB +} + +func (this *CustomNameNinOptNative) GetFieldC() *int32 { + return this.FieldC +} + +func (this *CustomNameNinOptNative) GetFieldD() *int64 { + return this.FieldD +} + +func (this *CustomNameNinOptNative) GetFieldE() *uint32 { + return this.FieldE +} + +func (this *CustomNameNinOptNative) GetFieldF() *uint64 { + return this.FieldF +} + +func (this *CustomNameNinOptNative) GetFieldG() *int32 { + return this.FieldG +} + +func (this *CustomNameNinOptNative) GetFieldH() *int64 { + return this.FieldH +} + +func (this *CustomNameNinOptNative) GetFieldI() *uint32 { + return this.FieldI +} + +func (this *CustomNameNinOptNative) GetFieldJ() *int32 { + return this.FieldJ +} + +func (this *CustomNameNinOptNative) GetFieldK() *uint64 { + return this.FieldK +} + +func (this *CustomNameNinOptNative) GetFielL() *int64 { + return this.FielL +} + +func (this *CustomNameNinOptNative) GetFieldM() *bool { + return this.FieldM +} + +func (this *CustomNameNinOptNative) GetFieldN() *string { + return this.FieldN +} + +func (this *CustomNameNinOptNative) GetFieldO() []byte { + return this.FieldO +} + +func NewCustomNameNinOptNativeFromFace(that CustomNameNinOptNativeFace) *CustomNameNinOptNative { + this := &CustomNameNinOptNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FielL = that.GetFielL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() []float64 + GetFieldB() []float32 + GetFieldC() []int32 + GetFieldD() []int64 + GetFieldE() []uint32 + GetFieldF() []uint64 + GetFieldG() []int32 + GetFieldH() []int64 + GetFieldI() []uint32 + GetFieldJ() []int32 + GetFieldK() []uint64 + GetFieldL() []int64 + GetFieldM() []bool + GetFieldN() []string + GetFieldO() [][]byte +} + +func (this *CustomNameNinRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinRepNativeFromFace(this) +} + +func (this *CustomNameNinRepNative) GetFieldA() []float64 { + return this.FieldA +} + +func (this *CustomNameNinRepNative) GetFieldB() []float32 { + return this.FieldB +} + +func (this *CustomNameNinRepNative) GetFieldC() []int32 { + return this.FieldC +} + +func (this *CustomNameNinRepNative) GetFieldD() []int64 { + return this.FieldD +} + +func (this *CustomNameNinRepNative) GetFieldE() []uint32 { + return this.FieldE +} + +func (this *CustomNameNinRepNative) GetFieldF() []uint64 { + return this.FieldF +} + +func (this *CustomNameNinRepNative) GetFieldG() []int32 { + return this.FieldG +} + +func (this *CustomNameNinRepNative) GetFieldH() []int64 { + return this.FieldH +} + +func (this *CustomNameNinRepNative) GetFieldI() []uint32 { + return this.FieldI +} + +func (this *CustomNameNinRepNative) GetFieldJ() []int32 { + return this.FieldJ +} + +func (this *CustomNameNinRepNative) GetFieldK() []uint64 { + return this.FieldK +} + +func (this *CustomNameNinRepNative) GetFieldL() []int64 { + return this.FieldL +} + +func (this *CustomNameNinRepNative) GetFieldM() []bool { + return this.FieldM +} + +func (this *CustomNameNinRepNative) GetFieldN() []string { + return this.FieldN +} + +func (this *CustomNameNinRepNative) GetFieldO() [][]byte { + return this.FieldO +} + +func NewCustomNameNinRepNativeFromFace(that CustomNameNinRepNativeFace) *CustomNameNinRepNative { + this := &CustomNameNinRepNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FieldL = that.GetFieldL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *float64 + GetFieldB() *float32 + GetFieldC() *NidOptNative + GetFieldD() []*NinOptNative + GetFieldE() *uint64 + GetFieldF() *int32 + GetFieldG() *NidOptNative + GetFieldH() *bool + GetFieldI() *string + GetFieldJ() []byte +} + +func (this *CustomNameNinStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinStructFromFace(this) +} + +func (this *CustomNameNinStruct) GetFieldA() *float64 { + return this.FieldA +} + +func (this *CustomNameNinStruct) GetFieldB() *float32 { + return this.FieldB +} + +func (this *CustomNameNinStruct) GetFieldC() *NidOptNative { + return this.FieldC +} + +func (this *CustomNameNinStruct) GetFieldD() []*NinOptNative { + return this.FieldD +} + +func (this *CustomNameNinStruct) GetFieldE() *uint64 { + return this.FieldE +} + +func (this *CustomNameNinStruct) GetFieldF() *int32 { + return this.FieldF +} + +func (this *CustomNameNinStruct) GetFieldG() *NidOptNative { + return this.FieldG +} + +func (this *CustomNameNinStruct) GetFieldH() *bool { + return this.FieldH +} + +func (this *CustomNameNinStruct) GetFieldI() *string { + return this.FieldI +} + +func (this *CustomNameNinStruct) GetFieldJ() []byte { + return this.FieldJ +} + +func NewCustomNameNinStructFromFace(that CustomNameNinStructFace) *CustomNameNinStruct { + this := &CustomNameNinStruct{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + return this +} + +type CustomNameCustomTypeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *Uuid + GetFieldB() *github_com_gogo_protobuf_test_custom.Uint128 + GetFieldC() []Uuid + GetFieldD() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *CustomNameCustomType) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameCustomType) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameCustomTypeFromFace(this) +} + +func (this *CustomNameCustomType) GetFieldA() *Uuid { + return this.FieldA +} + +func (this *CustomNameCustomType) GetFieldB() *github_com_gogo_protobuf_test_custom.Uint128 { + return this.FieldB +} + +func (this *CustomNameCustomType) GetFieldC() []Uuid { + return this.FieldC +} + +func (this *CustomNameCustomType) GetFieldD() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.FieldD +} + +func NewCustomNameCustomTypeFromFace(that CustomNameCustomTypeFace) *CustomNameCustomType { + this := &CustomNameCustomType{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + return this +} + +type CustomNameNinEmbeddedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetFieldA() *NinOptNative + GetFieldB() *bool +} + +func (this *CustomNameNinEmbeddedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinEmbeddedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinEmbeddedStructUnionFromFace(this) +} + +func (this *CustomNameNinEmbeddedStructUnion) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *CustomNameNinEmbeddedStructUnion) GetFieldA() *NinOptNative { + return this.FieldA +} + +func (this *CustomNameNinEmbeddedStructUnion) GetFieldB() *bool { + return this.FieldB +} + +func NewCustomNameNinEmbeddedStructUnionFromFace(that CustomNameNinEmbeddedStructUnionFace) *CustomNameNinEmbeddedStructUnion { + this := &CustomNameNinEmbeddedStructUnion{} + this.NidOptNative = that.GetNidOptNative() + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + return this +} + +type CustomNameEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *TheTestEnum + GetFieldB() []TheTestEnum +} + +func (this *CustomNameEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameEnumFromFace(this) +} + +func (this *CustomNameEnum) GetFieldA() *TheTestEnum { + return this.FieldA +} + +func (this *CustomNameEnum) GetFieldB() []TheTestEnum { + return this.FieldB +} + +func NewCustomNameEnumFromFace(that CustomNameEnumFace) *CustomNameEnum { + this := &CustomNameEnum{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + return this +} + +type UnrecognizedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *string +} + +func (this *Unrecognized) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Unrecognized) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedFromFace(this) +} + +func (this *Unrecognized) GetField1() *string { + return this.Field1 +} + +func NewUnrecognizedFromFace(that UnrecognizedFace) *Unrecognized { + this := &Unrecognized{} + this.Field1 = that.GetField1() + return this +} + +type UnrecognizedWithInnerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetEmbedded() []*UnrecognizedWithInner_Inner + GetField2() *string +} + +func (this *UnrecognizedWithInner) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithInner) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithInnerFromFace(this) +} + +func (this *UnrecognizedWithInner) GetEmbedded() []*UnrecognizedWithInner_Inner { + return this.Embedded +} + +func (this *UnrecognizedWithInner) GetField2() *string { + return this.Field2 +} + +func NewUnrecognizedWithInnerFromFace(that UnrecognizedWithInnerFace) *UnrecognizedWithInner { + this := &UnrecognizedWithInner{} + this.Embedded = that.GetEmbedded() + this.Field2 = that.GetField2() + return this +} + +type UnrecognizedWithInner_InnerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *uint32 +} + +func (this *UnrecognizedWithInner_Inner) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithInner_Inner) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithInner_InnerFromFace(this) +} + +func (this *UnrecognizedWithInner_Inner) GetField1() *uint32 { + return this.Field1 +} + +func NewUnrecognizedWithInner_InnerFromFace(that UnrecognizedWithInner_InnerFace) *UnrecognizedWithInner_Inner { + this := &UnrecognizedWithInner_Inner{} + this.Field1 = that.GetField1() + return this +} + +type UnrecognizedWithEmbedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetUnrecognizedWithEmbed_Embedded() UnrecognizedWithEmbed_Embedded + GetField2() *string +} + +func (this *UnrecognizedWithEmbed) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithEmbed) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithEmbedFromFace(this) +} + +func (this *UnrecognizedWithEmbed) GetUnrecognizedWithEmbed_Embedded() UnrecognizedWithEmbed_Embedded { + return this.UnrecognizedWithEmbed_Embedded +} + +func (this *UnrecognizedWithEmbed) GetField2() *string { + return this.Field2 +} + +func NewUnrecognizedWithEmbedFromFace(that UnrecognizedWithEmbedFace) *UnrecognizedWithEmbed { + this := &UnrecognizedWithEmbed{} + this.UnrecognizedWithEmbed_Embedded = that.GetUnrecognizedWithEmbed_Embedded() + this.Field2 = that.GetField2() + return this +} + +type UnrecognizedWithEmbed_EmbeddedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *uint32 +} + +func (this *UnrecognizedWithEmbed_Embedded) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithEmbed_Embedded) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithEmbed_EmbeddedFromFace(this) +} + +func (this *UnrecognizedWithEmbed_Embedded) GetField1() *uint32 { + return this.Field1 +} + +func NewUnrecognizedWithEmbed_EmbeddedFromFace(that UnrecognizedWithEmbed_EmbeddedFace) *UnrecognizedWithEmbed_Embedded { + this := &UnrecognizedWithEmbed_Embedded{} + this.Field1 = that.GetField1() + return this +} + +func (this *NidOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NidOptNative{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinOptNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+valueToGoStringThetest(this.Field8, "int64")+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+valueToGoStringThetest(this.Field9, "uint32")+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+valueToGoStringThetest(this.Field10, "int32")+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+valueToGoStringThetest(this.Field11, "uint64")+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+valueToGoStringThetest(this.Field12, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NidRepNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinRepNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepPackedNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 17) + s = append(s, "&test.NidRepPackedNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepPackedNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 17) + s = append(s, "&test.NinRepPackedNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NidOptStruct{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + s = append(s, "Field3: "+strings.Replace(this.Field3.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field4: "+strings.Replace(this.Field4.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + s = append(s, "Field8: "+strings.Replace(this.Field8.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NinOptStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NidRepStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+strings.Replace(fmt.Sprintf("%#v", this.Field3), `&`, ``, 1)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+strings.Replace(fmt.Sprintf("%#v", this.Field4), `&`, ``, 1)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+strings.Replace(fmt.Sprintf("%#v", this.Field8), `&`, ``, 1)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NinRepStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidEmbeddedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NidEmbeddedStruct{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + s = append(s, "Field200: "+strings.Replace(this.Field200.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field210: "+fmt.Sprintf("%#v", this.Field210)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinEmbeddedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinEmbeddedStruct{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.Field200 != nil { + s = append(s, "Field200: "+fmt.Sprintf("%#v", this.Field200)+",\n") + } + if this.Field210 != nil { + s = append(s, "Field210: "+valueToGoStringThetest(this.Field210, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidNestedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidNestedStruct{") + s = append(s, "Field1: "+strings.Replace(this.Field1.GoString(), `&`, ``, 1)+",\n") + if this.Field2 != nil { + s = append(s, "Field2: "+strings.Replace(fmt.Sprintf("%#v", this.Field2), `&`, ``, 1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinNestedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinNestedStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidOptCustom{") + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomDash) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.CustomDash{") + if this.Value != nil { + s = append(s, "Value: "+valueToGoStringThetest(this.Value, "github_com_gogo_protobuf_test_custom_dash_type.Bytes")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinOptCustom{") + if this.Id != nil { + s = append(s, "Id: "+valueToGoStringThetest(this.Id, "Uuid")+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+valueToGoStringThetest(this.Value, "github_com_gogo_protobuf_test_custom.Uint128")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidRepCustom{") + if this.Id != nil { + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinRepCustom{") + if this.Id != nil { + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNativeUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 13) + s = append(s, "&test.NinOptNativeUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 13) + s = append(s, "&test.NinOptStructUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinEmbeddedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinEmbeddedStructUnion{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.Field200 != nil { + s = append(s, "Field200: "+fmt.Sprintf("%#v", this.Field200)+",\n") + } + if this.Field210 != nil { + s = append(s, "Field210: "+valueToGoStringThetest(this.Field210, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinNestedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinNestedStructUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Tree) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.Tree{") + if this.Or != nil { + s = append(s, "Or: "+fmt.Sprintf("%#v", this.Or)+",\n") + } + if this.And != nil { + s = append(s, "And: "+fmt.Sprintf("%#v", this.And)+",\n") + } + if this.Leaf != nil { + s = append(s, "Leaf: "+fmt.Sprintf("%#v", this.Leaf)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OrBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.OrBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AndBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.AndBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Leaf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.Leaf{") + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + s = append(s, "StrValue: "+fmt.Sprintf("%#v", this.StrValue)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DeepTree) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.DeepTree{") + if this.Down != nil { + s = append(s, "Down: "+fmt.Sprintf("%#v", this.Down)+",\n") + } + if this.And != nil { + s = append(s, "And: "+fmt.Sprintf("%#v", this.And)+",\n") + } + if this.Leaf != nil { + s = append(s, "Leaf: "+fmt.Sprintf("%#v", this.Leaf)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *ADeepBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.ADeepBranch{") + s = append(s, "Down: "+strings.Replace(this.Down.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AndDeepBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.AndDeepBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DeepLeaf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.DeepLeaf{") + s = append(s, "Tree: "+strings.Replace(this.Tree.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Nil) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 4) + s = append(s, "&test.Nil{") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NidOptEnum{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinOptEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.TheTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NidRepEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinRepEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptEnumDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinOptEnumDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.TheTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AnotherNinOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.AnotherNinOptEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.AnotherTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AnotherNinOptEnumDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.AnotherNinOptEnumDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.AnotherTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Timer) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.Timer{") + s = append(s, "Time1: "+fmt.Sprintf("%#v", this.Time1)+",\n") + s = append(s, "Time2: "+fmt.Sprintf("%#v", this.Time2)+",\n") + s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MyExtendable) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.MyExtendable{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringThetest(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OtherExtenable) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.OtherExtenable{") + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "int64")+",\n") + } + if this.M != nil { + s = append(s, "M: "+fmt.Sprintf("%#v", this.M)+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringThetest(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&test.NestedDefinition{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.EnumField != nil { + s = append(s, "EnumField: "+valueToGoStringThetest(this.EnumField, "test.NestedDefinition_NestedEnum")+",\n") + } + if this.NNM != nil { + s = append(s, "NNM: "+fmt.Sprintf("%#v", this.NNM)+",\n") + } + if this.NM != nil { + s = append(s, "NM: "+fmt.Sprintf("%#v", this.NM)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition_NestedMessage) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NestedDefinition_NestedMessage{") + if this.NestedField1 != nil { + s = append(s, "NestedField1: "+valueToGoStringThetest(this.NestedField1, "uint64")+",\n") + } + if this.NNM != nil { + s = append(s, "NNM: "+fmt.Sprintf("%#v", this.NNM)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NestedDefinition_NestedMessage_NestedNestedMsg{") + if this.NestedNestedField1 != nil { + s = append(s, "NestedNestedField1: "+valueToGoStringThetest(this.NestedNestedField1, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedScope) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NestedScope{") + if this.A != nil { + s = append(s, "A: "+fmt.Sprintf("%#v", this.A)+",\n") + } + if this.B != nil { + s = append(s, "B: "+valueToGoStringThetest(this.B, "test.NestedDefinition_NestedEnum")+",\n") + } + if this.C != nil { + s = append(s, "C: "+fmt.Sprintf("%#v", this.C)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNativeDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinOptNativeDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+valueToGoStringThetest(this.Field8, "int64")+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+valueToGoStringThetest(this.Field9, "uint32")+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+valueToGoStringThetest(this.Field10, "int32")+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+valueToGoStringThetest(this.Field11, "uint64")+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+valueToGoStringThetest(this.Field12, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomContainer) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.CustomContainer{") + s = append(s, "CustomStruct: "+strings.Replace(this.CustomStruct.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNidOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNidOptNative{") + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + s = append(s, "FieldE: "+fmt.Sprintf("%#v", this.FieldE)+",\n") + s = append(s, "FieldF: "+fmt.Sprintf("%#v", this.FieldF)+",\n") + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + s = append(s, "FieldH: "+fmt.Sprintf("%#v", this.FieldH)+",\n") + s = append(s, "FieldI: "+fmt.Sprintf("%#v", this.FieldI)+",\n") + s = append(s, "FieldJ: "+fmt.Sprintf("%#v", this.FieldJ)+",\n") + s = append(s, "FieldK: "+fmt.Sprintf("%#v", this.FieldK)+",\n") + s = append(s, "FieldL: "+fmt.Sprintf("%#v", this.FieldL)+",\n") + s = append(s, "FieldM: "+fmt.Sprintf("%#v", this.FieldM)+",\n") + s = append(s, "FieldN: "+fmt.Sprintf("%#v", this.FieldN)+",\n") + s = append(s, "FieldO: "+fmt.Sprintf("%#v", this.FieldO)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNinOptNative{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "float64")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "float32")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+valueToGoStringThetest(this.FieldC, "int32")+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+valueToGoStringThetest(this.FieldD, "int64")+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+valueToGoStringThetest(this.FieldE, "uint32")+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+valueToGoStringThetest(this.FieldF, "uint64")+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+valueToGoStringThetest(this.FieldG, "int32")+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+valueToGoStringThetest(this.FieldH, "int64")+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+valueToGoStringThetest(this.FieldI, "uint32")+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+valueToGoStringThetest(this.FieldJ, "int32")+",\n") + } + if this.FieldK != nil { + s = append(s, "FieldK: "+valueToGoStringThetest(this.FieldK, "uint64")+",\n") + } + if this.FielL != nil { + s = append(s, "FielL: "+valueToGoStringThetest(this.FielL, "int64")+",\n") + } + if this.FieldM != nil { + s = append(s, "FieldM: "+valueToGoStringThetest(this.FieldM, "bool")+",\n") + } + if this.FieldN != nil { + s = append(s, "FieldN: "+valueToGoStringThetest(this.FieldN, "string")+",\n") + } + if this.FieldO != nil { + s = append(s, "FieldO: "+valueToGoStringThetest(this.FieldO, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNinRepNative{") + if this.FieldA != nil { + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+fmt.Sprintf("%#v", this.FieldE)+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+fmt.Sprintf("%#v", this.FieldF)+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+fmt.Sprintf("%#v", this.FieldH)+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+fmt.Sprintf("%#v", this.FieldI)+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+fmt.Sprintf("%#v", this.FieldJ)+",\n") + } + if this.FieldK != nil { + s = append(s, "FieldK: "+fmt.Sprintf("%#v", this.FieldK)+",\n") + } + if this.FieldL != nil { + s = append(s, "FieldL: "+fmt.Sprintf("%#v", this.FieldL)+",\n") + } + if this.FieldM != nil { + s = append(s, "FieldM: "+fmt.Sprintf("%#v", this.FieldM)+",\n") + } + if this.FieldN != nil { + s = append(s, "FieldN: "+fmt.Sprintf("%#v", this.FieldN)+",\n") + } + if this.FieldO != nil { + s = append(s, "FieldO: "+fmt.Sprintf("%#v", this.FieldO)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.CustomNameNinStruct{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "float64")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "float32")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+valueToGoStringThetest(this.FieldE, "uint64")+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+valueToGoStringThetest(this.FieldF, "int32")+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+valueToGoStringThetest(this.FieldH, "bool")+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+valueToGoStringThetest(this.FieldI, "string")+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+valueToGoStringThetest(this.FieldJ, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameCustomType) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&test.CustomNameCustomType{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "Uuid")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "github_com_gogo_protobuf_test_custom.Uint128")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinEmbeddedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.CustomNameNinEmbeddedStructUnion{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.FieldA != nil { + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.CustomNameEnum{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "test.TheTestEnum")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NoExtensionsMap) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NoExtensionsMap{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+fmt.Sprintf("%#v", this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Unrecognized) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.Unrecognized{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "string")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithInner) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.UnrecognizedWithInner{") + if this.Embedded != nil { + s = append(s, "Embedded: "+fmt.Sprintf("%#v", this.Embedded)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithInner_Inner) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.UnrecognizedWithInner_Inner{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "uint32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithEmbed) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.UnrecognizedWithEmbed{") + s = append(s, "UnrecognizedWithEmbed_Embedded: "+strings.Replace(this.UnrecognizedWithEmbed_Embedded.GoString(), `&`, ``, 1)+",\n") + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithEmbed_Embedded) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.UnrecognizedWithEmbed_Embedded{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "uint32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringThetest(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringThetest(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedNidOptNative(r randyThetest, easy bool) *NidOptNative { + this := &NidOptNative{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + this.Field5 = uint32(r.Uint32()) + this.Field6 = uint64(uint64(r.Uint32())) + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + this.Field9 = uint32(r.Uint32()) + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + this.Field11 = uint64(uint64(r.Uint32())) + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + this.Field13 = bool(bool(r.Intn(2) == 0)) + this.Field14 = randStringThetest(r) + v1 := r.Intn(100) + this.Field15 = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinOptNative(r randyThetest, easy bool) *NinOptNative { + this := &NinOptNative{} + if r.Intn(10) != 0 { + v2 := float64(r.Float64()) + if r.Intn(2) == 0 { + v2 *= -1 + } + this.Field1 = &v2 + } + if r.Intn(10) != 0 { + v3 := float32(r.Float32()) + if r.Intn(2) == 0 { + v3 *= -1 + } + this.Field2 = &v3 + } + if r.Intn(10) != 0 { + v4 := int32(r.Int31()) + if r.Intn(2) == 0 { + v4 *= -1 + } + this.Field3 = &v4 + } + if r.Intn(10) != 0 { + v5 := int64(r.Int63()) + if r.Intn(2) == 0 { + v5 *= -1 + } + this.Field4 = &v5 + } + if r.Intn(10) != 0 { + v6 := uint32(r.Uint32()) + this.Field5 = &v6 + } + if r.Intn(10) != 0 { + v7 := uint64(uint64(r.Uint32())) + this.Field6 = &v7 + } + if r.Intn(10) != 0 { + v8 := int32(r.Int31()) + if r.Intn(2) == 0 { + v8 *= -1 + } + this.Field7 = &v8 + } + if r.Intn(10) != 0 { + v9 := int64(r.Int63()) + if r.Intn(2) == 0 { + v9 *= -1 + } + this.Field8 = &v9 + } + if r.Intn(10) != 0 { + v10 := uint32(r.Uint32()) + this.Field9 = &v10 + } + if r.Intn(10) != 0 { + v11 := int32(r.Int31()) + if r.Intn(2) == 0 { + v11 *= -1 + } + this.Field10 = &v11 + } + if r.Intn(10) != 0 { + v12 := uint64(uint64(r.Uint32())) + this.Field11 = &v12 + } + if r.Intn(10) != 0 { + v13 := int64(r.Int63()) + if r.Intn(2) == 0 { + v13 *= -1 + } + this.Field12 = &v13 + } + if r.Intn(10) != 0 { + v14 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v14 + } + if r.Intn(10) != 0 { + v15 := randStringThetest(r) + this.Field14 = &v15 + } + if r.Intn(10) != 0 { + v16 := r.Intn(100) + this.Field15 = make([]byte, v16) + for i := 0; i < v16; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepNative(r randyThetest, easy bool) *NidRepNative { + this := &NidRepNative{} + if r.Intn(10) != 0 { + v17 := r.Intn(100) + this.Field1 = make([]float64, v17) + for i := 0; i < v17; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v18 := r.Intn(100) + this.Field2 = make([]float32, v18) + for i := 0; i < v18; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v19 := r.Intn(100) + this.Field3 = make([]int32, v19) + for i := 0; i < v19; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v20 := r.Intn(100) + this.Field4 = make([]int64, v20) + for i := 0; i < v20; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v21 := r.Intn(100) + this.Field5 = make([]uint32, v21) + for i := 0; i < v21; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v22 := r.Intn(100) + this.Field6 = make([]uint64, v22) + for i := 0; i < v22; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v23 := r.Intn(100) + this.Field7 = make([]int32, v23) + for i := 0; i < v23; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v24 := r.Intn(100) + this.Field8 = make([]int64, v24) + for i := 0; i < v24; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v25 := r.Intn(100) + this.Field9 = make([]uint32, v25) + for i := 0; i < v25; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v26 := r.Intn(100) + this.Field10 = make([]int32, v26) + for i := 0; i < v26; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v27 := r.Intn(100) + this.Field11 = make([]uint64, v27) + for i := 0; i < v27; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v28 := r.Intn(100) + this.Field12 = make([]int64, v28) + for i := 0; i < v28; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(100) + this.Field13 = make([]bool, v29) + for i := 0; i < v29; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v30 := r.Intn(10) + this.Field14 = make([]string, v30) + for i := 0; i < v30; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v31 := r.Intn(100) + this.Field15 = make([][]byte, v31) + for i := 0; i < v31; i++ { + v32 := r.Intn(100) + this.Field15[i] = make([]byte, v32) + for j := 0; j < v32; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinRepNative(r randyThetest, easy bool) *NinRepNative { + this := &NinRepNative{} + if r.Intn(10) != 0 { + v33 := r.Intn(100) + this.Field1 = make([]float64, v33) + for i := 0; i < v33; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v34 := r.Intn(100) + this.Field2 = make([]float32, v34) + for i := 0; i < v34; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v35 := r.Intn(100) + this.Field3 = make([]int32, v35) + for i := 0; i < v35; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v36 := r.Intn(100) + this.Field4 = make([]int64, v36) + for i := 0; i < v36; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v37 := r.Intn(100) + this.Field5 = make([]uint32, v37) + for i := 0; i < v37; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v38 := r.Intn(100) + this.Field6 = make([]uint64, v38) + for i := 0; i < v38; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v39 := r.Intn(100) + this.Field7 = make([]int32, v39) + for i := 0; i < v39; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v40 := r.Intn(100) + this.Field8 = make([]int64, v40) + for i := 0; i < v40; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v41 := r.Intn(100) + this.Field9 = make([]uint32, v41) + for i := 0; i < v41; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v42 := r.Intn(100) + this.Field10 = make([]int32, v42) + for i := 0; i < v42; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v43 := r.Intn(100) + this.Field11 = make([]uint64, v43) + for i := 0; i < v43; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v44 := r.Intn(100) + this.Field12 = make([]int64, v44) + for i := 0; i < v44; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v45 := r.Intn(100) + this.Field13 = make([]bool, v45) + for i := 0; i < v45; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v46 := r.Intn(10) + this.Field14 = make([]string, v46) + for i := 0; i < v46; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v47 := r.Intn(100) + this.Field15 = make([][]byte, v47) + for i := 0; i < v47; i++ { + v48 := r.Intn(100) + this.Field15[i] = make([]byte, v48) + for j := 0; j < v48; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepPackedNative(r randyThetest, easy bool) *NidRepPackedNative { + this := &NidRepPackedNative{} + if r.Intn(10) != 0 { + v49 := r.Intn(100) + this.Field1 = make([]float64, v49) + for i := 0; i < v49; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v50 := r.Intn(100) + this.Field2 = make([]float32, v50) + for i := 0; i < v50; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v51 := r.Intn(100) + this.Field3 = make([]int32, v51) + for i := 0; i < v51; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v52 := r.Intn(100) + this.Field4 = make([]int64, v52) + for i := 0; i < v52; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v53 := r.Intn(100) + this.Field5 = make([]uint32, v53) + for i := 0; i < v53; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v54 := r.Intn(100) + this.Field6 = make([]uint64, v54) + for i := 0; i < v54; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v55 := r.Intn(100) + this.Field7 = make([]int32, v55) + for i := 0; i < v55; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v56 := r.Intn(100) + this.Field8 = make([]int64, v56) + for i := 0; i < v56; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v57 := r.Intn(100) + this.Field9 = make([]uint32, v57) + for i := 0; i < v57; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v58 := r.Intn(100) + this.Field10 = make([]int32, v58) + for i := 0; i < v58; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v59 := r.Intn(100) + this.Field11 = make([]uint64, v59) + for i := 0; i < v59; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v60 := r.Intn(100) + this.Field12 = make([]int64, v60) + for i := 0; i < v60; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v61 := r.Intn(100) + this.Field13 = make([]bool, v61) + for i := 0; i < v61; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 14) + } + return this +} + +func NewPopulatedNinRepPackedNative(r randyThetest, easy bool) *NinRepPackedNative { + this := &NinRepPackedNative{} + if r.Intn(10) != 0 { + v62 := r.Intn(100) + this.Field1 = make([]float64, v62) + for i := 0; i < v62; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v63 := r.Intn(100) + this.Field2 = make([]float32, v63) + for i := 0; i < v63; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v64 := r.Intn(100) + this.Field3 = make([]int32, v64) + for i := 0; i < v64; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v65 := r.Intn(100) + this.Field4 = make([]int64, v65) + for i := 0; i < v65; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v66 := r.Intn(100) + this.Field5 = make([]uint32, v66) + for i := 0; i < v66; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v67 := r.Intn(100) + this.Field6 = make([]uint64, v67) + for i := 0; i < v67; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v68 := r.Intn(100) + this.Field7 = make([]int32, v68) + for i := 0; i < v68; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v69 := r.Intn(100) + this.Field8 = make([]int64, v69) + for i := 0; i < v69; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v70 := r.Intn(100) + this.Field9 = make([]uint32, v70) + for i := 0; i < v70; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v71 := r.Intn(100) + this.Field10 = make([]int32, v71) + for i := 0; i < v71; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v72 := r.Intn(100) + this.Field11 = make([]uint64, v72) + for i := 0; i < v72; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v73 := r.Intn(100) + this.Field12 = make([]int64, v73) + for i := 0; i < v73; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v74 := r.Intn(100) + this.Field13 = make([]bool, v74) + for i := 0; i < v74; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 14) + } + return this +} + +func NewPopulatedNidOptStruct(r randyThetest, easy bool) *NidOptStruct { + this := &NidOptStruct{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + v75 := NewPopulatedNidOptNative(r, easy) + this.Field3 = *v75 + v76 := NewPopulatedNinOptNative(r, easy) + this.Field4 = *v76 + this.Field6 = uint64(uint64(r.Uint32())) + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + v77 := NewPopulatedNidOptNative(r, easy) + this.Field8 = *v77 + this.Field13 = bool(bool(r.Intn(2) == 0)) + this.Field14 = randStringThetest(r) + v78 := r.Intn(100) + this.Field15 = make([]byte, v78) + for i := 0; i < v78; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinOptStruct(r randyThetest, easy bool) *NinOptStruct { + this := &NinOptStruct{} + if r.Intn(10) != 0 { + v79 := float64(r.Float64()) + if r.Intn(2) == 0 { + v79 *= -1 + } + this.Field1 = &v79 + } + if r.Intn(10) != 0 { + v80 := float32(r.Float32()) + if r.Intn(2) == 0 { + v80 *= -1 + } + this.Field2 = &v80 + } + if r.Intn(10) != 0 { + this.Field3 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + this.Field4 = NewPopulatedNinOptNative(r, easy) + } + if r.Intn(10) != 0 { + v81 := uint64(uint64(r.Uint32())) + this.Field6 = &v81 + } + if r.Intn(10) != 0 { + v82 := int32(r.Int31()) + if r.Intn(2) == 0 { + v82 *= -1 + } + this.Field7 = &v82 + } + if r.Intn(10) != 0 { + this.Field8 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v83 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v83 + } + if r.Intn(10) != 0 { + v84 := randStringThetest(r) + this.Field14 = &v84 + } + if r.Intn(10) != 0 { + v85 := r.Intn(100) + this.Field15 = make([]byte, v85) + for i := 0; i < v85; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepStruct(r randyThetest, easy bool) *NidRepStruct { + this := &NidRepStruct{} + if r.Intn(10) != 0 { + v86 := r.Intn(100) + this.Field1 = make([]float64, v86) + for i := 0; i < v86; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v87 := r.Intn(100) + this.Field2 = make([]float32, v87) + for i := 0; i < v87; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v88 := r.Intn(10) + this.Field3 = make([]NidOptNative, v88) + for i := 0; i < v88; i++ { + v89 := NewPopulatedNidOptNative(r, easy) + this.Field3[i] = *v89 + } + } + if r.Intn(10) != 0 { + v90 := r.Intn(10) + this.Field4 = make([]NinOptNative, v90) + for i := 0; i < v90; i++ { + v91 := NewPopulatedNinOptNative(r, easy) + this.Field4[i] = *v91 + } + } + if r.Intn(10) != 0 { + v92 := r.Intn(100) + this.Field6 = make([]uint64, v92) + for i := 0; i < v92; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v93 := r.Intn(100) + this.Field7 = make([]int32, v93) + for i := 0; i < v93; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v94 := r.Intn(10) + this.Field8 = make([]NidOptNative, v94) + for i := 0; i < v94; i++ { + v95 := NewPopulatedNidOptNative(r, easy) + this.Field8[i] = *v95 + } + } + if r.Intn(10) != 0 { + v96 := r.Intn(100) + this.Field13 = make([]bool, v96) + for i := 0; i < v96; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v97 := r.Intn(10) + this.Field14 = make([]string, v97) + for i := 0; i < v97; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v98 := r.Intn(100) + this.Field15 = make([][]byte, v98) + for i := 0; i < v98; i++ { + v99 := r.Intn(100) + this.Field15[i] = make([]byte, v99) + for j := 0; j < v99; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinRepStruct(r randyThetest, easy bool) *NinRepStruct { + this := &NinRepStruct{} + if r.Intn(10) != 0 { + v100 := r.Intn(100) + this.Field1 = make([]float64, v100) + for i := 0; i < v100; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v101 := r.Intn(100) + this.Field2 = make([]float32, v101) + for i := 0; i < v101; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v102 := r.Intn(10) + this.Field3 = make([]*NidOptNative, v102) + for i := 0; i < v102; i++ { + this.Field3[i] = NewPopulatedNidOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v103 := r.Intn(10) + this.Field4 = make([]*NinOptNative, v103) + for i := 0; i < v103; i++ { + this.Field4[i] = NewPopulatedNinOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v104 := r.Intn(100) + this.Field6 = make([]uint64, v104) + for i := 0; i < v104; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v105 := r.Intn(100) + this.Field7 = make([]int32, v105) + for i := 0; i < v105; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v106 := r.Intn(10) + this.Field8 = make([]*NidOptNative, v106) + for i := 0; i < v106; i++ { + this.Field8[i] = NewPopulatedNidOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v107 := r.Intn(100) + this.Field13 = make([]bool, v107) + for i := 0; i < v107; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v108 := r.Intn(10) + this.Field14 = make([]string, v108) + for i := 0; i < v108; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v109 := r.Intn(100) + this.Field15 = make([][]byte, v109) + for i := 0; i < v109; i++ { + v110 := r.Intn(100) + this.Field15[i] = make([]byte, v110) + for j := 0; j < v110; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidEmbeddedStruct(r randyThetest, easy bool) *NidEmbeddedStruct { + this := &NidEmbeddedStruct{} + if r.Intn(10) != 0 { + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + } + v111 := NewPopulatedNidOptNative(r, easy) + this.Field200 = *v111 + this.Field210 = bool(bool(r.Intn(2) == 0)) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 211) + } + return this +} + +func NewPopulatedNinEmbeddedStruct(r randyThetest, easy bool) *NinEmbeddedStruct { + this := &NinEmbeddedStruct{} + if r.Intn(10) != 0 { + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + this.Field200 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v112 := bool(bool(r.Intn(2) == 0)) + this.Field210 = &v112 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 211) + } + return this +} + +func NewPopulatedNidNestedStruct(r randyThetest, easy bool) *NidNestedStruct { + this := &NidNestedStruct{} + v113 := NewPopulatedNidOptStruct(r, easy) + this.Field1 = *v113 + if r.Intn(10) != 0 { + v114 := r.Intn(10) + this.Field2 = make([]NidRepStruct, v114) + for i := 0; i < v114; i++ { + v115 := NewPopulatedNidRepStruct(r, easy) + this.Field2[i] = *v115 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinNestedStruct(r randyThetest, easy bool) *NinNestedStruct { + this := &NinNestedStruct{} + if r.Intn(10) != 0 { + this.Field1 = NewPopulatedNinOptStruct(r, easy) + } + if r.Intn(10) != 0 { + v116 := r.Intn(10) + this.Field2 = make([]*NinRepStruct, v116) + for i := 0; i < v116; i++ { + this.Field2[i] = NewPopulatedNinRepStruct(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNidOptCustom(r randyThetest, easy bool) *NidOptCustom { + this := &NidOptCustom{} + v117 := NewPopulatedUuid(r) + this.Id = *v117 + v118 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value = *v118 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedCustomDash(r randyThetest, easy bool) *CustomDash { + this := &CustomDash{} + if r.Intn(10) != 0 { + this.Value = github_com_gogo_protobuf_test_custom_dash_type.NewPopulatedBytes(r) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptCustom(r randyThetest, easy bool) *NinOptCustom { + this := &NinOptCustom{} + if r.Intn(10) != 0 { + this.Id = NewPopulatedUuid(r) + } + if r.Intn(10) != 0 { + this.Value = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNidRepCustom(r randyThetest, easy bool) *NidRepCustom { + this := &NidRepCustom{} + if r.Intn(10) != 0 { + v119 := r.Intn(10) + this.Id = make([]Uuid, v119) + for i := 0; i < v119; i++ { + v120 := NewPopulatedUuid(r) + this.Id[i] = *v120 + } + } + if r.Intn(10) != 0 { + v121 := r.Intn(10) + this.Value = make([]github_com_gogo_protobuf_test_custom.Uint128, v121) + for i := 0; i < v121; i++ { + v122 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value[i] = *v122 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinRepCustom(r randyThetest, easy bool) *NinRepCustom { + this := &NinRepCustom{} + if r.Intn(10) != 0 { + v123 := r.Intn(10) + this.Id = make([]Uuid, v123) + for i := 0; i < v123; i++ { + v124 := NewPopulatedUuid(r) + this.Id[i] = *v124 + } + } + if r.Intn(10) != 0 { + v125 := r.Intn(10) + this.Value = make([]github_com_gogo_protobuf_test_custom.Uint128, v125) + for i := 0; i < v125; i++ { + v126 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value[i] = *v126 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinOptNativeUnion(r randyThetest, easy bool) *NinOptNativeUnion { + this := &NinOptNativeUnion{} + fieldNum := r.Intn(9) + switch fieldNum { + case 0: + v127 := float64(r.Float64()) + if r.Intn(2) == 0 { + v127 *= -1 + } + this.Field1 = &v127 + case 1: + v128 := float32(r.Float32()) + if r.Intn(2) == 0 { + v128 *= -1 + } + this.Field2 = &v128 + case 2: + v129 := int32(r.Int31()) + if r.Intn(2) == 0 { + v129 *= -1 + } + this.Field3 = &v129 + case 3: + v130 := int64(r.Int63()) + if r.Intn(2) == 0 { + v130 *= -1 + } + this.Field4 = &v130 + case 4: + v131 := uint32(r.Uint32()) + this.Field5 = &v131 + case 5: + v132 := uint64(uint64(r.Uint32())) + this.Field6 = &v132 + case 6: + v133 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v133 + case 7: + v134 := randStringThetest(r) + this.Field14 = &v134 + case 8: + v135 := r.Intn(100) + this.Field15 = make([]byte, v135) + for i := 0; i < v135; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + return this +} + +func NewPopulatedNinOptStructUnion(r randyThetest, easy bool) *NinOptStructUnion { + this := &NinOptStructUnion{} + fieldNum := r.Intn(9) + switch fieldNum { + case 0: + v136 := float64(r.Float64()) + if r.Intn(2) == 0 { + v136 *= -1 + } + this.Field1 = &v136 + case 1: + v137 := float32(r.Float32()) + if r.Intn(2) == 0 { + v137 *= -1 + } + this.Field2 = &v137 + case 2: + this.Field3 = NewPopulatedNidOptNative(r, easy) + case 3: + this.Field4 = NewPopulatedNinOptNative(r, easy) + case 4: + v138 := uint64(uint64(r.Uint32())) + this.Field6 = &v138 + case 5: + v139 := int32(r.Int31()) + if r.Intn(2) == 0 { + v139 *= -1 + } + this.Field7 = &v139 + case 6: + v140 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v140 + case 7: + v141 := randStringThetest(r) + this.Field14 = &v141 + case 8: + v142 := r.Intn(100) + this.Field15 = make([]byte, v142) + for i := 0; i < v142; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + return this +} + +func NewPopulatedNinEmbeddedStructUnion(r randyThetest, easy bool) *NinEmbeddedStructUnion { + this := &NinEmbeddedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + case 1: + this.Field200 = NewPopulatedNinOptNative(r, easy) + case 2: + v143 := bool(bool(r.Intn(2) == 0)) + this.Field210 = &v143 + } + return this +} + +func NewPopulatedNinNestedStructUnion(r randyThetest, easy bool) *NinNestedStructUnion { + this := &NinNestedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.Field1 = NewPopulatedNinOptNativeUnion(r, easy) + case 1: + this.Field2 = NewPopulatedNinOptStructUnion(r, easy) + case 2: + this.Field3 = NewPopulatedNinEmbeddedStructUnion(r, easy) + } + return this +} + +func NewPopulatedTree(r randyThetest, easy bool) *Tree { + this := &Tree{} + fieldNum := r.Intn(102) + switch fieldNum { + case 0: + this.Or = NewPopulatedOrBranch(r, easy) + case 1: + this.And = NewPopulatedAndBranch(r, easy) + case 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101: + this.Leaf = NewPopulatedLeaf(r, easy) + } + return this +} + +func NewPopulatedOrBranch(r randyThetest, easy bool) *OrBranch { + this := &OrBranch{} + v144 := NewPopulatedTree(r, easy) + this.Left = *v144 + v145 := NewPopulatedTree(r, easy) + this.Right = *v145 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedAndBranch(r randyThetest, easy bool) *AndBranch { + this := &AndBranch{} + v146 := NewPopulatedTree(r, easy) + this.Left = *v146 + v147 := NewPopulatedTree(r, easy) + this.Right = *v147 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedLeaf(r randyThetest, easy bool) *Leaf { + this := &Leaf{} + this.Value = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Value *= -1 + } + this.StrValue = randStringThetest(r) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedDeepTree(r randyThetest, easy bool) *DeepTree { + this := &DeepTree{} + fieldNum := r.Intn(102) + switch fieldNum { + case 0: + this.Down = NewPopulatedADeepBranch(r, easy) + case 1: + this.And = NewPopulatedAndDeepBranch(r, easy) + case 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101: + this.Leaf = NewPopulatedDeepLeaf(r, easy) + } + return this +} + +func NewPopulatedADeepBranch(r randyThetest, easy bool) *ADeepBranch { + this := &ADeepBranch{} + v148 := NewPopulatedDeepTree(r, easy) + this.Down = *v148 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedAndDeepBranch(r randyThetest, easy bool) *AndDeepBranch { + this := &AndDeepBranch{} + v149 := NewPopulatedDeepTree(r, easy) + this.Left = *v149 + v150 := NewPopulatedDeepTree(r, easy) + this.Right = *v150 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedDeepLeaf(r randyThetest, easy bool) *DeepLeaf { + this := &DeepLeaf{} + v151 := NewPopulatedTree(r, easy) + this.Tree = *v151 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNil(r randyThetest, easy bool) *Nil { + this := &Nil{} + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 1) + } + return this +} + +func NewPopulatedNidOptEnum(r randyThetest, easy bool) *NidOptEnum { + this := &NidOptEnum{} + this.Field1 = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptEnum(r randyThetest, easy bool) *NinOptEnum { + this := &NinOptEnum{} + if r.Intn(10) != 0 { + v152 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.Field1 = &v152 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNidRepEnum(r randyThetest, easy bool) *NidRepEnum { + this := &NidRepEnum{} + if r.Intn(10) != 0 { + v153 := r.Intn(10) + this.Field1 = make([]TheTestEnum, v153) + for i := 0; i < v153; i++ { + this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinRepEnum(r randyThetest, easy bool) *NinRepEnum { + this := &NinRepEnum{} + if r.Intn(10) != 0 { + v154 := r.Intn(10) + this.Field1 = make([]TheTestEnum, v154) + for i := 0; i < v154; i++ { + this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptEnumDefault(r randyThetest, easy bool) *NinOptEnumDefault { + this := &NinOptEnumDefault{} + if r.Intn(10) != 0 { + v155 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.Field1 = &v155 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedAnotherNinOptEnum(r randyThetest, easy bool) *AnotherNinOptEnum { + this := &AnotherNinOptEnum{} + if r.Intn(10) != 0 { + v156 := AnotherTestEnum([]int32{10, 11}[r.Intn(2)]) + this.Field1 = &v156 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedAnotherNinOptEnumDefault(r randyThetest, easy bool) *AnotherNinOptEnumDefault { + this := &AnotherNinOptEnumDefault{} + if r.Intn(10) != 0 { + v157 := AnotherTestEnum([]int32{10, 11}[r.Intn(2)]) + this.Field1 = &v157 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedTimer(r randyThetest, easy bool) *Timer { + this := &Timer{} + this.Time1 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Time1 *= -1 + } + this.Time2 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Time2 *= -1 + } + v158 := r.Intn(100) + this.Data = make([]byte, v158) + for i := 0; i < v158; i++ { + this.Data[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 4) + } + return this +} + +func NewPopulatedMyExtendable(r randyThetest, easy bool) *MyExtendable { + this := &MyExtendable{} + if r.Intn(10) != 0 { + v159 := int64(r.Int63()) + if r.Intn(2) == 0 { + v159 *= -1 + } + this.Field1 = &v159 + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + fieldNumber := r.Intn(100) + 100 + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 201) + } + return this +} + +func NewPopulatedOtherExtenable(r randyThetest, easy bool) *OtherExtenable { + this := &OtherExtenable{} + if r.Intn(10) != 0 { + v160 := int64(r.Int63()) + if r.Intn(2) == 0 { + v160 *= -1 + } + this.Field2 = &v160 + } + if r.Intn(10) != 0 { + v161 := int64(r.Int63()) + if r.Intn(2) == 0 { + v161 *= -1 + } + this.Field13 = &v161 + } + if r.Intn(10) != 0 { + this.M = NewPopulatedMyExtendable(r, easy) + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + eIndex := r.Intn(2) + fieldNumber := 0 + switch eIndex { + case 0: + fieldNumber = r.Intn(3) + 14 + case 1: + fieldNumber = r.Intn(3) + 10 + } + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 18) + } + return this +} + +func NewPopulatedNestedDefinition(r randyThetest, easy bool) *NestedDefinition { + this := &NestedDefinition{} + if r.Intn(10) != 0 { + v162 := int64(r.Int63()) + if r.Intn(2) == 0 { + v162 *= -1 + } + this.Field1 = &v162 + } + if r.Intn(10) != 0 { + v163 := NestedDefinition_NestedEnum([]int32{1}[r.Intn(1)]) + this.EnumField = &v163 + } + if r.Intn(10) != 0 { + this.NNM = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if r.Intn(10) != 0 { + this.NM = NewPopulatedNestedDefinition_NestedMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 5) + } + return this +} + +func NewPopulatedNestedDefinition_NestedMessage(r randyThetest, easy bool) *NestedDefinition_NestedMessage { + this := &NestedDefinition_NestedMessage{} + if r.Intn(10) != 0 { + v164 := uint64(uint64(r.Uint32())) + this.NestedField1 = &v164 + } + if r.Intn(10) != 0 { + this.NNM = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r randyThetest, easy bool) *NestedDefinition_NestedMessage_NestedNestedMsg { + this := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if r.Intn(10) != 0 { + v165 := randStringThetest(r) + this.NestedNestedField1 = &v165 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 11) + } + return this +} + +func NewPopulatedNestedScope(r randyThetest, easy bool) *NestedScope { + this := &NestedScope{} + if r.Intn(10) != 0 { + this.A = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if r.Intn(10) != 0 { + v166 := NestedDefinition_NestedEnum([]int32{1}[r.Intn(1)]) + this.B = &v166 + } + if r.Intn(10) != 0 { + this.C = NewPopulatedNestedDefinition_NestedMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 4) + } + return this +} + +func NewPopulatedNinOptNativeDefault(r randyThetest, easy bool) *NinOptNativeDefault { + this := &NinOptNativeDefault{} + if r.Intn(10) != 0 { + v167 := float64(r.Float64()) + if r.Intn(2) == 0 { + v167 *= -1 + } + this.Field1 = &v167 + } + if r.Intn(10) != 0 { + v168 := float32(r.Float32()) + if r.Intn(2) == 0 { + v168 *= -1 + } + this.Field2 = &v168 + } + if r.Intn(10) != 0 { + v169 := int32(r.Int31()) + if r.Intn(2) == 0 { + v169 *= -1 + } + this.Field3 = &v169 + } + if r.Intn(10) != 0 { + v170 := int64(r.Int63()) + if r.Intn(2) == 0 { + v170 *= -1 + } + this.Field4 = &v170 + } + if r.Intn(10) != 0 { + v171 := uint32(r.Uint32()) + this.Field5 = &v171 + } + if r.Intn(10) != 0 { + v172 := uint64(uint64(r.Uint32())) + this.Field6 = &v172 + } + if r.Intn(10) != 0 { + v173 := int32(r.Int31()) + if r.Intn(2) == 0 { + v173 *= -1 + } + this.Field7 = &v173 + } + if r.Intn(10) != 0 { + v174 := int64(r.Int63()) + if r.Intn(2) == 0 { + v174 *= -1 + } + this.Field8 = &v174 + } + if r.Intn(10) != 0 { + v175 := uint32(r.Uint32()) + this.Field9 = &v175 + } + if r.Intn(10) != 0 { + v176 := int32(r.Int31()) + if r.Intn(2) == 0 { + v176 *= -1 + } + this.Field10 = &v176 + } + if r.Intn(10) != 0 { + v177 := uint64(uint64(r.Uint32())) + this.Field11 = &v177 + } + if r.Intn(10) != 0 { + v178 := int64(r.Int63()) + if r.Intn(2) == 0 { + v178 *= -1 + } + this.Field12 = &v178 + } + if r.Intn(10) != 0 { + v179 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v179 + } + if r.Intn(10) != 0 { + v180 := randStringThetest(r) + this.Field14 = &v180 + } + if r.Intn(10) != 0 { + v181 := r.Intn(100) + this.Field15 = make([]byte, v181) + for i := 0; i < v181; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomContainer(r randyThetest, easy bool) *CustomContainer { + this := &CustomContainer{} + v182 := NewPopulatedNidOptCustom(r, easy) + this.CustomStruct = *v182 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedCustomNameNidOptNative(r randyThetest, easy bool) *CustomNameNidOptNative { + this := &CustomNameNidOptNative{} + this.FieldA = float64(r.Float64()) + if r.Intn(2) == 0 { + this.FieldA *= -1 + } + this.FieldB = float32(r.Float32()) + if r.Intn(2) == 0 { + this.FieldB *= -1 + } + this.FieldC = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldC *= -1 + } + this.FieldD = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldD *= -1 + } + this.FieldE = uint32(r.Uint32()) + this.FieldF = uint64(uint64(r.Uint32())) + this.FieldG = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldG *= -1 + } + this.FieldH = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldH *= -1 + } + this.FieldI = uint32(r.Uint32()) + this.FieldJ = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldJ *= -1 + } + this.FieldK = uint64(uint64(r.Uint32())) + this.FieldL = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldL *= -1 + } + this.FieldM = bool(bool(r.Intn(2) == 0)) + this.FieldN = randStringThetest(r) + v183 := r.Intn(100) + this.FieldO = make([]byte, v183) + for i := 0; i < v183; i++ { + this.FieldO[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinOptNative(r randyThetest, easy bool) *CustomNameNinOptNative { + this := &CustomNameNinOptNative{} + if r.Intn(10) != 0 { + v184 := float64(r.Float64()) + if r.Intn(2) == 0 { + v184 *= -1 + } + this.FieldA = &v184 + } + if r.Intn(10) != 0 { + v185 := float32(r.Float32()) + if r.Intn(2) == 0 { + v185 *= -1 + } + this.FieldB = &v185 + } + if r.Intn(10) != 0 { + v186 := int32(r.Int31()) + if r.Intn(2) == 0 { + v186 *= -1 + } + this.FieldC = &v186 + } + if r.Intn(10) != 0 { + v187 := int64(r.Int63()) + if r.Intn(2) == 0 { + v187 *= -1 + } + this.FieldD = &v187 + } + if r.Intn(10) != 0 { + v188 := uint32(r.Uint32()) + this.FieldE = &v188 + } + if r.Intn(10) != 0 { + v189 := uint64(uint64(r.Uint32())) + this.FieldF = &v189 + } + if r.Intn(10) != 0 { + v190 := int32(r.Int31()) + if r.Intn(2) == 0 { + v190 *= -1 + } + this.FieldG = &v190 + } + if r.Intn(10) != 0 { + v191 := int64(r.Int63()) + if r.Intn(2) == 0 { + v191 *= -1 + } + this.FieldH = &v191 + } + if r.Intn(10) != 0 { + v192 := uint32(r.Uint32()) + this.FieldI = &v192 + } + if r.Intn(10) != 0 { + v193 := int32(r.Int31()) + if r.Intn(2) == 0 { + v193 *= -1 + } + this.FieldJ = &v193 + } + if r.Intn(10) != 0 { + v194 := uint64(uint64(r.Uint32())) + this.FieldK = &v194 + } + if r.Intn(10) != 0 { + v195 := int64(r.Int63()) + if r.Intn(2) == 0 { + v195 *= -1 + } + this.FielL = &v195 + } + if r.Intn(10) != 0 { + v196 := bool(bool(r.Intn(2) == 0)) + this.FieldM = &v196 + } + if r.Intn(10) != 0 { + v197 := randStringThetest(r) + this.FieldN = &v197 + } + if r.Intn(10) != 0 { + v198 := r.Intn(100) + this.FieldO = make([]byte, v198) + for i := 0; i < v198; i++ { + this.FieldO[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinRepNative(r randyThetest, easy bool) *CustomNameNinRepNative { + this := &CustomNameNinRepNative{} + if r.Intn(10) != 0 { + v199 := r.Intn(100) + this.FieldA = make([]float64, v199) + for i := 0; i < v199; i++ { + this.FieldA[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.FieldA[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v200 := r.Intn(100) + this.FieldB = make([]float32, v200) + for i := 0; i < v200; i++ { + this.FieldB[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.FieldB[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v201 := r.Intn(100) + this.FieldC = make([]int32, v201) + for i := 0; i < v201; i++ { + this.FieldC[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldC[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v202 := r.Intn(100) + this.FieldD = make([]int64, v202) + for i := 0; i < v202; i++ { + this.FieldD[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldD[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v203 := r.Intn(100) + this.FieldE = make([]uint32, v203) + for i := 0; i < v203; i++ { + this.FieldE[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v204 := r.Intn(100) + this.FieldF = make([]uint64, v204) + for i := 0; i < v204; i++ { + this.FieldF[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v205 := r.Intn(100) + this.FieldG = make([]int32, v205) + for i := 0; i < v205; i++ { + this.FieldG[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldG[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v206 := r.Intn(100) + this.FieldH = make([]int64, v206) + for i := 0; i < v206; i++ { + this.FieldH[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldH[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v207 := r.Intn(100) + this.FieldI = make([]uint32, v207) + for i := 0; i < v207; i++ { + this.FieldI[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v208 := r.Intn(100) + this.FieldJ = make([]int32, v208) + for i := 0; i < v208; i++ { + this.FieldJ[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldJ[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v209 := r.Intn(100) + this.FieldK = make([]uint64, v209) + for i := 0; i < v209; i++ { + this.FieldK[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v210 := r.Intn(100) + this.FieldL = make([]int64, v210) + for i := 0; i < v210; i++ { + this.FieldL[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldL[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v211 := r.Intn(100) + this.FieldM = make([]bool, v211) + for i := 0; i < v211; i++ { + this.FieldM[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v212 := r.Intn(10) + this.FieldN = make([]string, v212) + for i := 0; i < v212; i++ { + this.FieldN[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v213 := r.Intn(100) + this.FieldO = make([][]byte, v213) + for i := 0; i < v213; i++ { + v214 := r.Intn(100) + this.FieldO[i] = make([]byte, v214) + for j := 0; j < v214; j++ { + this.FieldO[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinStruct(r randyThetest, easy bool) *CustomNameNinStruct { + this := &CustomNameNinStruct{} + if r.Intn(10) != 0 { + v215 := float64(r.Float64()) + if r.Intn(2) == 0 { + v215 *= -1 + } + this.FieldA = &v215 + } + if r.Intn(10) != 0 { + v216 := float32(r.Float32()) + if r.Intn(2) == 0 { + v216 *= -1 + } + this.FieldB = &v216 + } + if r.Intn(10) != 0 { + this.FieldC = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v217 := r.Intn(10) + this.FieldD = make([]*NinOptNative, v217) + for i := 0; i < v217; i++ { + this.FieldD[i] = NewPopulatedNinOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v218 := uint64(uint64(r.Uint32())) + this.FieldE = &v218 + } + if r.Intn(10) != 0 { + v219 := int32(r.Int31()) + if r.Intn(2) == 0 { + v219 *= -1 + } + this.FieldF = &v219 + } + if r.Intn(10) != 0 { + this.FieldG = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v220 := bool(bool(r.Intn(2) == 0)) + this.FieldH = &v220 + } + if r.Intn(10) != 0 { + v221 := randStringThetest(r) + this.FieldI = &v221 + } + if r.Intn(10) != 0 { + v222 := r.Intn(100) + this.FieldJ = make([]byte, v222) + for i := 0; i < v222; i++ { + this.FieldJ[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameCustomType(r randyThetest, easy bool) *CustomNameCustomType { + this := &CustomNameCustomType{} + if r.Intn(10) != 0 { + this.FieldA = NewPopulatedUuid(r) + } + if r.Intn(10) != 0 { + this.FieldB = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + } + if r.Intn(10) != 0 { + v223 := r.Intn(10) + this.FieldC = make([]Uuid, v223) + for i := 0; i < v223; i++ { + v224 := NewPopulatedUuid(r) + this.FieldC[i] = *v224 + } + } + if r.Intn(10) != 0 { + v225 := r.Intn(10) + this.FieldD = make([]github_com_gogo_protobuf_test_custom.Uint128, v225) + for i := 0; i < v225; i++ { + v226 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.FieldD[i] = *v226 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 5) + } + return this +} + +func NewPopulatedCustomNameNinEmbeddedStructUnion(r randyThetest, easy bool) *CustomNameNinEmbeddedStructUnion { + this := &CustomNameNinEmbeddedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + case 1: + this.FieldA = NewPopulatedNinOptNative(r, easy) + case 2: + v227 := bool(bool(r.Intn(2) == 0)) + this.FieldB = &v227 + } + return this +} + +func NewPopulatedCustomNameEnum(r randyThetest, easy bool) *CustomNameEnum { + this := &CustomNameEnum{} + if r.Intn(10) != 0 { + v228 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.FieldA = &v228 + } + if r.Intn(10) != 0 { + v229 := r.Intn(10) + this.FieldB = make([]TheTestEnum, v229) + for i := 0; i < v229; i++ { + this.FieldB[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNoExtensionsMap(r randyThetest, easy bool) *NoExtensionsMap { + this := &NoExtensionsMap{} + if r.Intn(10) != 0 { + v230 := int64(r.Int63()) + if r.Intn(2) == 0 { + v230 *= -1 + } + this.Field1 = &v230 + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + fieldNumber := r.Intn(100) + 100 + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 201) + } + return this +} + +func NewPopulatedUnrecognized(r randyThetest, easy bool) *Unrecognized { + this := &Unrecognized{} + if r.Intn(10) != 0 { + v231 := randStringThetest(r) + this.Field1 = &v231 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedUnrecognizedWithInner(r randyThetest, easy bool) *UnrecognizedWithInner { + this := &UnrecognizedWithInner{} + if r.Intn(10) != 0 { + v232 := r.Intn(10) + this.Embedded = make([]*UnrecognizedWithInner_Inner, v232) + for i := 0; i < v232; i++ { + this.Embedded[i] = NewPopulatedUnrecognizedWithInner_Inner(r, easy) + } + } + if r.Intn(10) != 0 { + v233 := randStringThetest(r) + this.Field2 = &v233 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedUnrecognizedWithInner_Inner(r randyThetest, easy bool) *UnrecognizedWithInner_Inner { + this := &UnrecognizedWithInner_Inner{} + if r.Intn(10) != 0 { + v234 := uint32(r.Uint32()) + this.Field1 = &v234 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedUnrecognizedWithEmbed(r randyThetest, easy bool) *UnrecognizedWithEmbed { + this := &UnrecognizedWithEmbed{} + v235 := NewPopulatedUnrecognizedWithEmbed_Embedded(r, easy) + this.UnrecognizedWithEmbed_Embedded = *v235 + if r.Intn(10) != 0 { + v236 := randStringThetest(r) + this.Field2 = &v236 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedUnrecognizedWithEmbed_Embedded(r randyThetest, easy bool) *UnrecognizedWithEmbed_Embedded { + this := &UnrecognizedWithEmbed_Embedded{} + if r.Intn(10) != 0 { + v237 := uint32(r.Uint32()) + this.Field1 = &v237 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +type randyThetest interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneThetest(r randyThetest) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringThetest(r randyThetest) string { + v238 := r.Intn(100) + tmps := make([]rune, v238) + for i := 0; i < v238; i++ { + tmps[i] = randUTF8RuneThetest(r) + } + return string(tmps) +} +func randUnrecognizedThetest(r randyThetest, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldThetest(data, r, fieldNumber, wire) + } + return data +} +func randFieldThetest(data []byte, r randyThetest, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateThetest(data, uint64(key)) + v239 := r.Int63() + if r.Intn(2) == 0 { + v239 *= -1 + } + data = encodeVarintPopulateThetest(data, uint64(v239)) + case 1: + data = encodeVarintPopulateThetest(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateThetest(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateThetest(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateThetest(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateThetest(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *NidOptNative) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + n += 1 + sovThetest(uint64(m.Field3)) + n += 1 + sovThetest(uint64(m.Field4)) + n += 1 + sovThetest(uint64(m.Field5)) + n += 1 + sovThetest(uint64(m.Field6)) + n += 1 + sozThetest(uint64(m.Field7)) + n += 1 + sozThetest(uint64(m.Field8)) + n += 5 + n += 5 + n += 9 + n += 9 + n += 2 + l = len(m.Field14) + n += 1 + l + sovThetest(uint64(l)) + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNative) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + n += 1 + sozThetest(uint64(*m.Field8)) + } + if m.Field9 != nil { + n += 5 + } + if m.Field10 != nil { + n += 5 + } + if m.Field11 != nil { + n += 9 + } + if m.Field12 != nil { + n += 9 + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field5) > 0 { + for _, e := range m.Field5 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field9) > 0 { + n += 5 * len(m.Field9) + } + if len(m.Field10) > 0 { + n += 5 * len(m.Field10) + } + if len(m.Field11) > 0 { + n += 9 * len(m.Field11) + } + if len(m.Field12) > 0 { + n += 9 * len(m.Field12) + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field5) > 0 { + for _, e := range m.Field5 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field9) > 0 { + n += 5 * len(m.Field9) + } + if len(m.Field10) > 0 { + n += 5 * len(m.Field10) + } + if len(m.Field11) > 0 { + n += 9 * len(m.Field11) + } + if len(m.Field12) > 0 { + n += 9 * len(m.Field12) + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepPackedNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 1 + sovThetest(uint64(len(m.Field1)*8)) + len(m.Field1)*8 + } + if len(m.Field2) > 0 { + n += 1 + sovThetest(uint64(len(m.Field2)*4)) + len(m.Field2)*4 + } + if len(m.Field3) > 0 { + l = 0 + for _, e := range m.Field3 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field4) > 0 { + l = 0 + for _, e := range m.Field4 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field5) > 0 { + l = 0 + for _, e := range m.Field5 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field6) > 0 { + l = 0 + for _, e := range m.Field6 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field7) > 0 { + l = 0 + for _, e := range m.Field7 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field8) > 0 { + l = 0 + for _, e := range m.Field8 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field9) > 0 { + n += 1 + sovThetest(uint64(len(m.Field9)*4)) + len(m.Field9)*4 + } + if len(m.Field10) > 0 { + n += 1 + sovThetest(uint64(len(m.Field10)*4)) + len(m.Field10)*4 + } + if len(m.Field11) > 0 { + n += 1 + sovThetest(uint64(len(m.Field11)*8)) + len(m.Field11)*8 + } + if len(m.Field12) > 0 { + n += 1 + sovThetest(uint64(len(m.Field12)*8)) + len(m.Field12)*8 + } + if len(m.Field13) > 0 { + n += 1 + sovThetest(uint64(len(m.Field13))) + len(m.Field13)*1 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepPackedNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 1 + sovThetest(uint64(len(m.Field1)*8)) + len(m.Field1)*8 + } + if len(m.Field2) > 0 { + n += 1 + sovThetest(uint64(len(m.Field2)*4)) + len(m.Field2)*4 + } + if len(m.Field3) > 0 { + l = 0 + for _, e := range m.Field3 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field4) > 0 { + l = 0 + for _, e := range m.Field4 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field5) > 0 { + l = 0 + for _, e := range m.Field5 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field6) > 0 { + l = 0 + for _, e := range m.Field6 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field7) > 0 { + l = 0 + for _, e := range m.Field7 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field8) > 0 { + l = 0 + for _, e := range m.Field8 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field9) > 0 { + n += 1 + sovThetest(uint64(len(m.Field9)*4)) + len(m.Field9)*4 + } + if len(m.Field10) > 0 { + n += 1 + sovThetest(uint64(len(m.Field10)*4)) + len(m.Field10)*4 + } + if len(m.Field11) > 0 { + n += 1 + sovThetest(uint64(len(m.Field11)*8)) + len(m.Field11)*8 + } + if len(m.Field12) > 0 { + n += 1 + sovThetest(uint64(len(m.Field12)*8)) + len(m.Field12)*8 + } + if len(m.Field13) > 0 { + n += 1 + sovThetest(uint64(len(m.Field13))) + len(m.Field13)*1 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptStruct) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + n += 1 + sovThetest(uint64(m.Field6)) + n += 1 + sozThetest(uint64(m.Field7)) + l = m.Field8.Size() + n += 1 + l + sovThetest(uint64(l)) + n += 2 + l = len(m.Field14) + n += 1 + l + sovThetest(uint64(l)) + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptStruct) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field4 != nil { + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + l = m.Field8.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepStruct) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepStruct) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidEmbeddedStruct) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + n += 3 + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinEmbeddedStruct) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field200 != nil { + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.Field210 != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidNestedStruct) Size() (n int) { + var l int + _ = l + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + if len(m.Field2) > 0 { + for _, e := range m.Field2 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinNestedStruct) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.Field2) > 0 { + for _, e := range m.Field2 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptCustom) Size() (n int) { + var l int + _ = l + l = m.Id.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomDash) Size() (n int) { + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptCustom) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepCustom) Size() (n int) { + var l int + _ = l + if len(m.Id) > 0 { + for _, e := range m.Id { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Value) > 0 { + for _, e := range m.Value { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepCustom) Size() (n int) { + var l int + _ = l + if len(m.Id) > 0 { + for _, e := range m.Id { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Value) > 0 { + for _, e := range m.Value { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNativeUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptStructUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field4 != nil { + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinEmbeddedStructUnion) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field200 != nil { + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.Field210 != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinNestedStructUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field2 != nil { + l = m.Field2.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Tree) Size() (n int) { + var l int + _ = l + if m.Or != nil { + l = m.Or.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.And != nil { + l = m.And.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Leaf != nil { + l = m.Leaf.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *OrBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AndBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Leaf) Size() (n int) { + var l int + _ = l + n += 1 + sovThetest(uint64(m.Value)) + l = len(m.StrValue) + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DeepTree) Size() (n int) { + var l int + _ = l + if m.Down != nil { + l = m.Down.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.And != nil { + l = m.And.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Leaf != nil { + l = m.Leaf.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ADeepBranch) Size() (n int) { + var l int + _ = l + l = m.Down.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AndDeepBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DeepLeaf) Size() (n int) { + var l int + _ = l + l = m.Tree.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Nil) Size() (n int) { + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptEnum) Size() (n int) { + var l int + _ = l + n += 1 + sovThetest(uint64(m.Field1)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptEnum) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepEnum) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + for _, e := range m.Field1 { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepEnum) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + for _, e := range m.Field1 { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptEnumDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AnotherNinOptEnum) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AnotherNinOptEnumDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Timer) Size() (n int) { + var l int + _ = l + n += 9 + n += 9 + if m.Data != nil { + l = len(m.Data) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *MyExtendable) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + n += github_com_gogo_protobuf_proto.SizeOfExtensionMap(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *OtherExtenable) Size() (n int) { + var l int + _ = l + if m.Field2 != nil { + n += 1 + sovThetest(uint64(*m.Field2)) + } + if m.Field13 != nil { + n += 1 + sovThetest(uint64(*m.Field13)) + } + if m.M != nil { + l = m.M.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_extensions != nil { + n += github_com_gogo_protobuf_proto.SizeOfExtensionMap(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.EnumField != nil { + n += 1 + sovThetest(uint64(*m.EnumField)) + } + if m.NNM != nil { + l = m.NNM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.NM != nil { + l = m.NM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition_NestedMessage) Size() (n int) { + var l int + _ = l + if m.NestedField1 != nil { + n += 9 + } + if m.NNM != nil { + l = m.NNM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Size() (n int) { + var l int + _ = l + if m.NestedNestedField1 != nil { + l = len(*m.NestedNestedField1) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedScope) Size() (n int) { + var l int + _ = l + if m.A != nil { + l = m.A.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.B != nil { + n += 1 + sovThetest(uint64(*m.B)) + } + if m.C != nil { + l = m.C.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNativeDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + n += 1 + sozThetest(uint64(*m.Field8)) + } + if m.Field9 != nil { + n += 5 + } + if m.Field10 != nil { + n += 5 + } + if m.Field11 != nil { + n += 9 + } + if m.Field12 != nil { + n += 9 + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomContainer) Size() (n int) { + var l int + _ = l + l = m.CustomStruct.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNidOptNative) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + n += 1 + sovThetest(uint64(m.FieldC)) + n += 1 + sovThetest(uint64(m.FieldD)) + n += 1 + sovThetest(uint64(m.FieldE)) + n += 1 + sovThetest(uint64(m.FieldF)) + n += 1 + sozThetest(uint64(m.FieldG)) + n += 1 + sozThetest(uint64(m.FieldH)) + n += 5 + n += 5 + n += 9 + n += 9 + n += 2 + l = len(m.FieldN) + n += 1 + l + sovThetest(uint64(l)) + if m.FieldO != nil { + l = len(m.FieldO) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinOptNative) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 9 + } + if m.FieldB != nil { + n += 5 + } + if m.FieldC != nil { + n += 1 + sovThetest(uint64(*m.FieldC)) + } + if m.FieldD != nil { + n += 1 + sovThetest(uint64(*m.FieldD)) + } + if m.FieldE != nil { + n += 1 + sovThetest(uint64(*m.FieldE)) + } + if m.FieldF != nil { + n += 1 + sovThetest(uint64(*m.FieldF)) + } + if m.FieldG != nil { + n += 1 + sozThetest(uint64(*m.FieldG)) + } + if m.FieldH != nil { + n += 1 + sozThetest(uint64(*m.FieldH)) + } + if m.FieldI != nil { + n += 5 + } + if m.FieldJ != nil { + n += 5 + } + if m.FieldK != nil { + n += 9 + } + if m.FielL != nil { + n += 9 + } + if m.FieldM != nil { + n += 2 + } + if m.FieldN != nil { + l = len(*m.FieldN) + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldO != nil { + l = len(m.FieldO) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinRepNative) Size() (n int) { + var l int + _ = l + if len(m.FieldA) > 0 { + n += 9 * len(m.FieldA) + } + if len(m.FieldB) > 0 { + n += 5 * len(m.FieldB) + } + if len(m.FieldC) > 0 { + for _, e := range m.FieldC { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldE) > 0 { + for _, e := range m.FieldE { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldF) > 0 { + for _, e := range m.FieldF { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldG) > 0 { + for _, e := range m.FieldG { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.FieldH) > 0 { + for _, e := range m.FieldH { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.FieldI) > 0 { + n += 5 * len(m.FieldI) + } + if len(m.FieldJ) > 0 { + n += 5 * len(m.FieldJ) + } + if len(m.FieldK) > 0 { + n += 9 * len(m.FieldK) + } + if len(m.FieldL) > 0 { + n += 9 * len(m.FieldL) + } + if len(m.FieldM) > 0 { + n += 2 * len(m.FieldM) + } + if len(m.FieldN) > 0 { + for _, s := range m.FieldN { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.FieldO) > 0 { + for _, b := range m.FieldO { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinStruct) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 9 + } + if m.FieldB != nil { + n += 5 + } + if m.FieldC != nil { + l = m.FieldC.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.FieldE != nil { + n += 1 + sovThetest(uint64(*m.FieldE)) + } + if m.FieldF != nil { + n += 1 + sozThetest(uint64(*m.FieldF)) + } + if m.FieldG != nil { + l = m.FieldG.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldH != nil { + n += 2 + } + if m.FieldI != nil { + l = len(*m.FieldI) + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldJ != nil { + l = len(m.FieldJ) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameCustomType) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + l = m.FieldA.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldB != nil { + l = m.FieldB.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.FieldC) > 0 { + for _, e := range m.FieldC { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinEmbeddedStructUnion) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldA != nil { + l = m.FieldA.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.FieldB != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameEnum) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 1 + sovThetest(uint64(*m.FieldA)) + } + if len(m.FieldB) > 0 { + for _, e := range m.FieldB { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NoExtensionsMap) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + n += len(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Unrecognized) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = len(*m.Field1) + n += 1 + l + sovThetest(uint64(l)) + } + return n +} + +func (m *UnrecognizedWithInner) Size() (n int) { + var l int + _ = l + if len(m.Embedded) > 0 { + for _, e := range m.Embedded { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.Field2 != nil { + l = len(*m.Field2) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UnrecognizedWithInner_Inner) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + return n +} + +func (m *UnrecognizedWithEmbed) Size() (n int) { + var l int + _ = l + l = m.UnrecognizedWithEmbed_Embedded.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.Field2 != nil { + l = len(*m.Field2) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UnrecognizedWithEmbed_Embedded) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + return n +} + +func sovThetest(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozThetest(x uint64) (n int) { + return sovThetest(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *NidOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNative{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + valueToStringThetest(this.Field8) + `,`, + `Field9:` + valueToStringThetest(this.Field9) + `,`, + `Field10:` + valueToStringThetest(this.Field10) + `,`, + `Field11:` + valueToStringThetest(this.Field11) + `,`, + `Field12:` + valueToStringThetest(this.Field12) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepPackedNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepPackedNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepPackedNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepPackedNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(strings.Replace(this.Field3.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field4:` + strings.Replace(strings.Replace(this.Field4.String(), "NinOptNative", "NinOptNative", 1), `&`, ``, 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(strings.Replace(this.Field8.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptStruct{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field4:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1), `&`, ``, 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidEmbeddedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidEmbeddedStruct{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(strings.Replace(this.Field200.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field210:` + fmt.Sprintf("%v", this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinEmbeddedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinEmbeddedStruct{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(fmt.Sprintf("%v", this.Field200), "NidOptNative", "NidOptNative", 1) + `,`, + `Field210:` + valueToStringThetest(this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidNestedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidNestedStruct{`, + `Field1:` + strings.Replace(strings.Replace(this.Field1.String(), "NidOptStruct", "NidOptStruct", 1), `&`, ``, 1) + `,`, + `Field2:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field2), "NidRepStruct", "NidRepStruct", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinNestedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinNestedStruct{`, + `Field1:` + strings.Replace(fmt.Sprintf("%v", this.Field1), "NinOptStruct", "NinOptStruct", 1) + `,`, + `Field2:` + strings.Replace(fmt.Sprintf("%v", this.Field2), "NinRepStruct", "NinRepStruct", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomDash) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomDash{`, + `Value:` + valueToStringThetest(this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptCustom{`, + `Id:` + valueToStringThetest(this.Id) + `,`, + `Value:` + valueToStringThetest(this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNativeUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNativeUnion{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptStructUnion{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinEmbeddedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinEmbeddedStructUnion{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(fmt.Sprintf("%v", this.Field200), "NinOptNative", "NinOptNative", 1) + `,`, + `Field210:` + valueToStringThetest(this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinNestedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinNestedStructUnion{`, + `Field1:` + strings.Replace(fmt.Sprintf("%v", this.Field1), "NinOptNativeUnion", "NinOptNativeUnion", 1) + `,`, + `Field2:` + strings.Replace(fmt.Sprintf("%v", this.Field2), "NinOptStructUnion", "NinOptStructUnion", 1) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NinEmbeddedStructUnion", "NinEmbeddedStructUnion", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Tree) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Tree{`, + `Or:` + strings.Replace(fmt.Sprintf("%v", this.Or), "OrBranch", "OrBranch", 1) + `,`, + `And:` + strings.Replace(fmt.Sprintf("%v", this.And), "AndBranch", "AndBranch", 1) + `,`, + `Leaf:` + strings.Replace(fmt.Sprintf("%v", this.Leaf), "Leaf", "Leaf", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OrBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OrBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AndBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AndBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Leaf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Leaf{`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `StrValue:` + fmt.Sprintf("%v", this.StrValue) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *DeepTree) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DeepTree{`, + `Down:` + strings.Replace(fmt.Sprintf("%v", this.Down), "ADeepBranch", "ADeepBranch", 1) + `,`, + `And:` + strings.Replace(fmt.Sprintf("%v", this.And), "AndDeepBranch", "AndDeepBranch", 1) + `,`, + `Leaf:` + strings.Replace(fmt.Sprintf("%v", this.Leaf), "DeepLeaf", "DeepLeaf", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ADeepBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ADeepBranch{`, + `Down:` + strings.Replace(strings.Replace(this.Down.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AndDeepBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AndDeepBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *DeepLeaf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DeepLeaf{`, + `Tree:` + strings.Replace(strings.Replace(this.Tree.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Nil) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Nil{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptEnum{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptEnumDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptEnumDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AnotherNinOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnotherNinOptEnum{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AnotherNinOptEnumDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnotherNinOptEnumDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Timer) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Timer{`, + `Time1:` + fmt.Sprintf("%v", this.Time1) + `,`, + `Time2:` + fmt.Sprintf("%v", this.Time2) + `,`, + `Data:` + fmt.Sprintf("%v", this.Data) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *MyExtendable) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&MyExtendable{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsMap(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OtherExtenable) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OtherExtenable{`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `M:` + strings.Replace(fmt.Sprintf("%v", this.M), "MyExtendable", "MyExtendable", 1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsMap(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `EnumField:` + valueToStringThetest(this.EnumField) + `,`, + `NNM:` + strings.Replace(fmt.Sprintf("%v", this.NNM), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `NM:` + strings.Replace(fmt.Sprintf("%v", this.NM), "NestedDefinition_NestedMessage", "NestedDefinition_NestedMessage", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition_NestedMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition_NestedMessage{`, + `NestedField1:` + valueToStringThetest(this.NestedField1) + `,`, + `NNM:` + strings.Replace(fmt.Sprintf("%v", this.NNM), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition_NestedMessage_NestedNestedMsg{`, + `NestedNestedField1:` + valueToStringThetest(this.NestedNestedField1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedScope) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedScope{`, + `A:` + strings.Replace(fmt.Sprintf("%v", this.A), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `B:` + valueToStringThetest(this.B) + `,`, + `C:` + strings.Replace(fmt.Sprintf("%v", this.C), "NestedDefinition_NestedMessage", "NestedDefinition_NestedMessage", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNativeDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNativeDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + valueToStringThetest(this.Field8) + `,`, + `Field9:` + valueToStringThetest(this.Field9) + `,`, + `Field10:` + valueToStringThetest(this.Field10) + `,`, + `Field11:` + valueToStringThetest(this.Field11) + `,`, + `Field12:` + valueToStringThetest(this.Field12) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomContainer) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomContainer{`, + `CustomStruct:` + strings.Replace(strings.Replace(this.CustomStruct.String(), "NidOptCustom", "NidOptCustom", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNidOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNidOptNative{`, + `FieldA:` + fmt.Sprintf("%v", this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `FieldE:` + fmt.Sprintf("%v", this.FieldE) + `,`, + `FieldF:` + fmt.Sprintf("%v", this.FieldF) + `,`, + `FieldG:` + fmt.Sprintf("%v", this.FieldG) + `,`, + `FieldH:` + fmt.Sprintf("%v", this.FieldH) + `,`, + `FieldI:` + fmt.Sprintf("%v", this.FieldI) + `,`, + `FieldJ:` + fmt.Sprintf("%v", this.FieldJ) + `,`, + `FieldK:` + fmt.Sprintf("%v", this.FieldK) + `,`, + `FieldL:` + fmt.Sprintf("%v", this.FieldL) + `,`, + `FieldM:` + fmt.Sprintf("%v", this.FieldM) + `,`, + `FieldN:` + fmt.Sprintf("%v", this.FieldN) + `,`, + `FieldO:` + fmt.Sprintf("%v", this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinOptNative{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + valueToStringThetest(this.FieldC) + `,`, + `FieldD:` + valueToStringThetest(this.FieldD) + `,`, + `FieldE:` + valueToStringThetest(this.FieldE) + `,`, + `FieldF:` + valueToStringThetest(this.FieldF) + `,`, + `FieldG:` + valueToStringThetest(this.FieldG) + `,`, + `FieldH:` + valueToStringThetest(this.FieldH) + `,`, + `FieldI:` + valueToStringThetest(this.FieldI) + `,`, + `FieldJ:` + valueToStringThetest(this.FieldJ) + `,`, + `FieldK:` + valueToStringThetest(this.FieldK) + `,`, + `FielL:` + valueToStringThetest(this.FielL) + `,`, + `FieldM:` + valueToStringThetest(this.FieldM) + `,`, + `FieldN:` + valueToStringThetest(this.FieldN) + `,`, + `FieldO:` + valueToStringThetest(this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinRepNative{`, + `FieldA:` + fmt.Sprintf("%v", this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `FieldE:` + fmt.Sprintf("%v", this.FieldE) + `,`, + `FieldF:` + fmt.Sprintf("%v", this.FieldF) + `,`, + `FieldG:` + fmt.Sprintf("%v", this.FieldG) + `,`, + `FieldH:` + fmt.Sprintf("%v", this.FieldH) + `,`, + `FieldI:` + fmt.Sprintf("%v", this.FieldI) + `,`, + `FieldJ:` + fmt.Sprintf("%v", this.FieldJ) + `,`, + `FieldK:` + fmt.Sprintf("%v", this.FieldK) + `,`, + `FieldL:` + fmt.Sprintf("%v", this.FieldL) + `,`, + `FieldM:` + fmt.Sprintf("%v", this.FieldM) + `,`, + `FieldN:` + fmt.Sprintf("%v", this.FieldN) + `,`, + `FieldO:` + fmt.Sprintf("%v", this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinStruct{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + strings.Replace(fmt.Sprintf("%v", this.FieldC), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldD:` + strings.Replace(fmt.Sprintf("%v", this.FieldD), "NinOptNative", "NinOptNative", 1) + `,`, + `FieldE:` + valueToStringThetest(this.FieldE) + `,`, + `FieldF:` + valueToStringThetest(this.FieldF) + `,`, + `FieldG:` + strings.Replace(fmt.Sprintf("%v", this.FieldG), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldH:` + valueToStringThetest(this.FieldH) + `,`, + `FieldI:` + valueToStringThetest(this.FieldI) + `,`, + `FieldJ:` + valueToStringThetest(this.FieldJ) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameCustomType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameCustomType{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinEmbeddedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinEmbeddedStructUnion{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldA:` + strings.Replace(fmt.Sprintf("%v", this.FieldA), "NinOptNative", "NinOptNative", 1) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameEnum{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NoExtensionsMap) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NoExtensionsMap{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsBytes(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Unrecognized) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Unrecognized{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithInner) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithInner{`, + `Embedded:` + strings.Replace(fmt.Sprintf("%v", this.Embedded), "UnrecognizedWithInner_Inner", "UnrecognizedWithInner_Inner", 1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithInner_Inner) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithInner_Inner{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithEmbed) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithEmbed{`, + `UnrecognizedWithEmbed_Embedded:` + strings.Replace(strings.Replace(this.UnrecognizedWithEmbed_Embedded.String(), "UnrecognizedWithEmbed_Embedded", "UnrecognizedWithEmbed_Embedded", 1), `&`, ``, 1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithEmbed_Embedded) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithEmbed_Embedded{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func valueToStringThetest(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (this *NinOptNativeUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + if this.Field4 != nil { + return this.Field4 + } + if this.Field5 != nil { + return this.Field5 + } + if this.Field6 != nil { + return this.Field6 + } + if this.Field13 != nil { + return this.Field13 + } + if this.Field14 != nil { + return this.Field14 + } + if this.Field15 != nil { + return this.Field15 + } + return nil +} + +func (this *NinOptNativeUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *float64: + this.Field1 = vt + case *float32: + this.Field2 = vt + case *int32: + this.Field3 = vt + case *int64: + this.Field4 = vt + case *uint32: + this.Field5 = vt + case *uint64: + this.Field6 = vt + case *bool: + this.Field13 = vt + case *string: + this.Field14 = vt + case []byte: + this.Field15 = vt + default: + return false + } + return true +} +func (this *NinOptStructUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + if this.Field4 != nil { + return this.Field4 + } + if this.Field6 != nil { + return this.Field6 + } + if this.Field7 != nil { + return this.Field7 + } + if this.Field13 != nil { + return this.Field13 + } + if this.Field14 != nil { + return this.Field14 + } + if this.Field15 != nil { + return this.Field15 + } + return nil +} + +func (this *NinOptStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *float64: + this.Field1 = vt + case *float32: + this.Field2 = vt + case *NidOptNative: + this.Field3 = vt + case *NinOptNative: + this.Field4 = vt + case *uint64: + this.Field6 = vt + case *int32: + this.Field7 = vt + case *bool: + this.Field13 = vt + case *string: + this.Field14 = vt + case []byte: + this.Field15 = vt + default: + return false + } + return true +} +func (this *NinEmbeddedStructUnion) GetValue() interface{} { + if this.NidOptNative != nil { + return this.NidOptNative + } + if this.Field200 != nil { + return this.Field200 + } + if this.Field210 != nil { + return this.Field210 + } + return nil +} + +func (this *NinEmbeddedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NidOptNative: + this.NidOptNative = vt + case *NinOptNative: + this.Field200 = vt + case *bool: + this.Field210 = vt + default: + return false + } + return true +} +func (this *NinNestedStructUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + return nil +} + +func (this *NinNestedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NinOptNativeUnion: + this.Field1 = vt + case *NinOptStructUnion: + this.Field2 = vt + case *NinEmbeddedStructUnion: + this.Field3 = vt + default: + this.Field1 = new(NinOptNativeUnion) + if set := this.Field1.SetValue(value); set { + return true + } + this.Field1 = nil + this.Field2 = new(NinOptStructUnion) + if set := this.Field2.SetValue(value); set { + return true + } + this.Field2 = nil + this.Field3 = new(NinEmbeddedStructUnion) + if set := this.Field3.SetValue(value); set { + return true + } + this.Field3 = nil + return false + } + return true +} +func (this *Tree) GetValue() interface{} { + if this.Or != nil { + return this.Or + } + if this.And != nil { + return this.And + } + if this.Leaf != nil { + return this.Leaf + } + return nil +} + +func (this *Tree) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *OrBranch: + this.Or = vt + case *AndBranch: + this.And = vt + case *Leaf: + this.Leaf = vt + default: + return false + } + return true +} +func (this *DeepTree) GetValue() interface{} { + if this.Down != nil { + return this.Down + } + if this.And != nil { + return this.And + } + if this.Leaf != nil { + return this.Leaf + } + return nil +} + +func (this *DeepTree) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *ADeepBranch: + this.Down = vt + case *AndDeepBranch: + this.And = vt + case *DeepLeaf: + this.Leaf = vt + default: + return false + } + return true +} +func (this *CustomNameNinEmbeddedStructUnion) GetValue() interface{} { + if this.NidOptNative != nil { + return this.NidOptNative + } + if this.FieldA != nil { + return this.FieldA + } + if this.FieldB != nil { + return this.FieldB + } + return nil +} + +func (this *CustomNameNinEmbeddedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NidOptNative: + this.NidOptNative = vt + case *NinOptNative: + this.FieldA = vt + case *bool: + this.FieldB = vt + default: + return false + } + return true +} +func (m *NidOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = m.Field1 + i += 8 + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = m.Field2 + i += 4 + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3)) + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field4)) + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field5)) + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field6)) + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31)))) + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(m.Field8)<<1)^uint64((m.Field8>>63)))) + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = m.Field9 + i += 4 + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = m.Field10 + i += 4 + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = m.Field11 + i += 8 + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = m.Field12 + i += 8 + data[i] = 0x68 + i++ + if m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field14))) + i += copy(data[i:], m.Field14) + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = *m.Field1 + i += 8 + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = *m.Field2 + i += 4 + } + if m.Field3 != nil { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field3)) + } + if m.Field4 != nil { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field4)) + } + if m.Field5 != nil { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field5)) + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field8 != nil { + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(*m.Field8)<<1)^uint64((*m.Field8>>63)))) + } + if m.Field9 != nil { + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = *m.Field9 + i += 4 + } + if m.Field10 != nil { + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = *m.Field10 + i += 4 + } + if m.Field11 != nil { + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = *m.Field11 + i += 8 + } + if m.Field12 != nil { + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = *m.Field12 + i += 8 + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field3) > 0 { + for _, num := range m.Field3 { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field4) > 0 { + for _, num := range m.Field4 { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field5) > 0 { + for _, num := range m.Field5 { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field6) > 0 { + for _, num := range m.Field6 { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x38 + i++ + x1 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x1 >= 1<<7 { + data[i] = uint8(uint64(x1)&0x7f | 0x80) + x1 >>= 7 + i++ + } + data[i] = uint8(x1) + i++ + } + } + if len(m.Field8) > 0 { + for _, num := range m.Field8 { + data[i] = 0x40 + i++ + x2 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x2 >= 1<<7 { + data[i] = uint8(uint64(x2)&0x7f | 0x80) + x2 >>= 7 + i++ + } + data[i] = uint8(x2) + i++ + } + } + if len(m.Field9) > 0 { + for _, num := range m.Field9 { + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field10) > 0 { + for _, num := range m.Field10 { + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field11) > 0 { + for _, num := range m.Field11 { + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field12) > 0 { + for _, num := range m.Field12 { + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field13) > 0 { + for _, b := range m.Field13 { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field3) > 0 { + for _, num := range m.Field3 { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field4) > 0 { + for _, num := range m.Field4 { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field5) > 0 { + for _, num := range m.Field5 { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field6) > 0 { + for _, num := range m.Field6 { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x38 + i++ + x3 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x3 >= 1<<7 { + data[i] = uint8(uint64(x3)&0x7f | 0x80) + x3 >>= 7 + i++ + } + data[i] = uint8(x3) + i++ + } + } + if len(m.Field8) > 0 { + for _, num := range m.Field8 { + data[i] = 0x40 + i++ + x4 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x4 >= 1<<7 { + data[i] = uint8(uint64(x4)&0x7f | 0x80) + x4 >>= 7 + i++ + } + data[i] = uint8(x4) + i++ + } + } + if len(m.Field9) > 0 { + for _, num := range m.Field9 { + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field10) > 0 { + for _, num := range m.Field10 { + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field11) > 0 { + for _, num := range m.Field11 { + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field12) > 0 { + for _, num := range m.Field12 { + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field13) > 0 { + for _, b := range m.Field13 { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepPackedNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepPackedNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field1)*8)) + for _, num := range m.Field1 { + *(*float64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field2) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field2)*4)) + for _, num := range m.Field2 { + *(*float32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field3) > 0 { + data6 := make([]byte, len(m.Field3)*10) + var j5 int + for _, num1 := range m.Field3 { + num := uint64(num1) + for num >= 1<<7 { + data6[j5] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j5++ + } + data6[j5] = uint8(num) + j5++ + } + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(j5)) + i += copy(data[i:], data6[:j5]) + } + if len(m.Field4) > 0 { + data8 := make([]byte, len(m.Field4)*10) + var j7 int + for _, num1 := range m.Field4 { + num := uint64(num1) + for num >= 1<<7 { + data8[j7] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j7++ + } + data8[j7] = uint8(num) + j7++ + } + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(j7)) + i += copy(data[i:], data8[:j7]) + } + if len(m.Field5) > 0 { + data10 := make([]byte, len(m.Field5)*10) + var j9 int + for _, num := range m.Field5 { + for num >= 1<<7 { + data10[j9] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j9++ + } + data10[j9] = uint8(num) + j9++ + } + data[i] = 0x2a + i++ + i = encodeVarintThetest(data, i, uint64(j9)) + i += copy(data[i:], data10[:j9]) + } + if len(m.Field6) > 0 { + data12 := make([]byte, len(m.Field6)*10) + var j11 int + for _, num := range m.Field6 { + for num >= 1<<7 { + data12[j11] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j11++ + } + data12[j11] = uint8(num) + j11++ + } + data[i] = 0x32 + i++ + i = encodeVarintThetest(data, i, uint64(j11)) + i += copy(data[i:], data12[:j11]) + } + if len(m.Field7) > 0 { + data13 := make([]byte, len(m.Field7)*5) + var j14 int + for _, num := range m.Field7 { + x15 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x15 >= 1<<7 { + data13[j14] = uint8(uint64(x15)&0x7f | 0x80) + j14++ + x15 >>= 7 + } + data13[j14] = uint8(x15) + j14++ + } + data[i] = 0x3a + i++ + i = encodeVarintThetest(data, i, uint64(j14)) + i += copy(data[i:], data13[:j14]) + } + if len(m.Field8) > 0 { + var j16 int + data18 := make([]byte, len(m.Field8)*10) + for _, num := range m.Field8 { + x17 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x17 >= 1<<7 { + data18[j16] = uint8(uint64(x17)&0x7f | 0x80) + j16++ + x17 >>= 7 + } + data18[j16] = uint8(x17) + j16++ + } + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(j16)) + i += copy(data[i:], data18[:j16]) + } + if len(m.Field9) > 0 { + data[i] = 0x4a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field9)*4)) + for _, num := range m.Field9 { + *(*uint32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field10) > 0 { + data[i] = 0x52 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field10)*4)) + for _, num := range m.Field10 { + *(*int32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field11) > 0 { + data[i] = 0x5a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field11)*8)) + for _, num := range m.Field11 { + *(*uint64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field12) > 0 { + data[i] = 0x62 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field12)*8)) + for _, num := range m.Field12 { + *(*int64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field13) > 0 { + data[i] = 0x6a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field13))) + for _, b := range m.Field13 { + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepPackedNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepPackedNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field1)*8)) + for _, num := range m.Field1 { + *(*float64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field2) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field2)*4)) + for _, num := range m.Field2 { + *(*float32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field3) > 0 { + data20 := make([]byte, len(m.Field3)*10) + var j19 int + for _, num1 := range m.Field3 { + num := uint64(num1) + for num >= 1<<7 { + data20[j19] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j19++ + } + data20[j19] = uint8(num) + j19++ + } + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(j19)) + i += copy(data[i:], data20[:j19]) + } + if len(m.Field4) > 0 { + data22 := make([]byte, len(m.Field4)*10) + var j21 int + for _, num1 := range m.Field4 { + num := uint64(num1) + for num >= 1<<7 { + data22[j21] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j21++ + } + data22[j21] = uint8(num) + j21++ + } + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(j21)) + i += copy(data[i:], data22[:j21]) + } + if len(m.Field5) > 0 { + data24 := make([]byte, len(m.Field5)*10) + var j23 int + for _, num := range m.Field5 { + for num >= 1<<7 { + data24[j23] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j23++ + } + data24[j23] = uint8(num) + j23++ + } + data[i] = 0x2a + i++ + i = encodeVarintThetest(data, i, uint64(j23)) + i += copy(data[i:], data24[:j23]) + } + if len(m.Field6) > 0 { + data26 := make([]byte, len(m.Field6)*10) + var j25 int + for _, num := range m.Field6 { + for num >= 1<<7 { + data26[j25] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j25++ + } + data26[j25] = uint8(num) + j25++ + } + data[i] = 0x32 + i++ + i = encodeVarintThetest(data, i, uint64(j25)) + i += copy(data[i:], data26[:j25]) + } + if len(m.Field7) > 0 { + data27 := make([]byte, len(m.Field7)*5) + var j28 int + for _, num := range m.Field7 { + x29 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x29 >= 1<<7 { + data27[j28] = uint8(uint64(x29)&0x7f | 0x80) + j28++ + x29 >>= 7 + } + data27[j28] = uint8(x29) + j28++ + } + data[i] = 0x3a + i++ + i = encodeVarintThetest(data, i, uint64(j28)) + i += copy(data[i:], data27[:j28]) + } + if len(m.Field8) > 0 { + var j30 int + data32 := make([]byte, len(m.Field8)*10) + for _, num := range m.Field8 { + x31 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x31 >= 1<<7 { + data32[j30] = uint8(uint64(x31)&0x7f | 0x80) + j30++ + x31 >>= 7 + } + data32[j30] = uint8(x31) + j30++ + } + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(j30)) + i += copy(data[i:], data32[:j30]) + } + if len(m.Field9) > 0 { + data[i] = 0x4a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field9)*4)) + for _, num := range m.Field9 { + *(*uint32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field10) > 0 { + data[i] = 0x52 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field10)*4)) + for _, num := range m.Field10 { + *(*int32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field11) > 0 { + data[i] = 0x5a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field11)*8)) + for _, num := range m.Field11 { + *(*uint64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field12) > 0 { + data[i] = 0x62 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field12)*8)) + for _, num := range m.Field12 { + *(*int64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field13) > 0 { + data[i] = 0x6a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field13))) + for _, b := range m.Field13 { + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidOptStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidOptStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = m.Field1 + i += 8 + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = m.Field2 + i += 4 + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3.Size())) + n33, err := m.Field3.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n33 + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field4.Size())) + n34, err := m.Field4.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n34 + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field6)) + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31)))) + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field8.Size())) + n35, err := m.Field8.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n35 + data[i] = 0x68 + i++ + if m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field14))) + i += copy(data[i:], m.Field14) + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = *m.Field1 + i += 8 + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = *m.Field2 + i += 4 + } + if m.Field3 != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3.Size())) + n36, err := m.Field3.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n36 + } + if m.Field4 != nil { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field4.Size())) + n37, err := m.Field4.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n37 + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field8 != nil { + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field8.Size())) + n38, err := m.Field8.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n38 + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field3) > 0 { + for _, msg := range m.Field3 { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field4) > 0 { + for _, msg := range m.Field4 { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field6) > 0 { + for _, num := range m.Field6 { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x38 + i++ + x39 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x39 >= 1<<7 { + data[i] = uint8(uint64(x39)&0x7f | 0x80) + x39 >>= 7 + i++ + } + data[i] = uint8(x39) + i++ + } + } + if len(m.Field8) > 0 { + for _, msg := range m.Field8 { + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field13) > 0 { + for _, b := range m.Field13 { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.Field3) > 0 { + for _, msg := range m.Field3 { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field4) > 0 { + for _, msg := range m.Field4 { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field6) > 0 { + for _, num := range m.Field6 { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x38 + i++ + x40 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x40 >= 1<<7 { + data[i] = uint8(uint64(x40)&0x7f | 0x80) + x40 >>= 7 + i++ + } + data[i] = uint8(x40) + i++ + } + } + if len(m.Field8) > 0 { + for _, msg := range m.Field8 { + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Field13) > 0 { + for _, b := range m.Field13 { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidEmbeddedStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidEmbeddedStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NidOptNative != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.NidOptNative.Size())) + n41, err := m.NidOptNative.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n41 + } + data[i] = 0xc2 + i++ + data[i] = 0xc + i++ + i = encodeVarintThetest(data, i, uint64(m.Field200.Size())) + n42, err := m.Field200.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n42 + data[i] = 0x90 + i++ + data[i] = 0xd + i++ + if m.Field210 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinEmbeddedStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinEmbeddedStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NidOptNative != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.NidOptNative.Size())) + n43, err := m.NidOptNative.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n43 + } + if m.Field200 != nil { + data[i] = 0xc2 + i++ + data[i] = 0xc + i++ + i = encodeVarintThetest(data, i, uint64(m.Field200.Size())) + n44, err := m.Field200.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n44 + } + if m.Field210 != nil { + data[i] = 0x90 + i++ + data[i] = 0xd + i++ + if *m.Field210 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidNestedStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidNestedStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Field1.Size())) + n45, err := m.Field1.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n45 + if len(m.Field2) > 0 { + for _, msg := range m.Field2 { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinNestedStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinNestedStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Field1.Size())) + n46, err := m.Field1.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n46 + } + if len(m.Field2) > 0 { + for _, msg := range m.Field2 { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidOptCustom) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidOptCustom) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Id.Size())) + n47, err := m.Id.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n47 + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Value.Size())) + n48, err := m.Value.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n48 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomDash) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomDash) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Value != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Value.Size())) + n49, err := m.Value.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n49 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptCustom) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptCustom) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Id != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Id.Size())) + n50, err := m.Id.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n50 + } + if m.Value != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Value.Size())) + n51, err := m.Value.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n51 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepCustom) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepCustom) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Id) > 0 { + for _, msg := range m.Id { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Value) > 0 { + for _, msg := range m.Value { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepCustom) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepCustom) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Id) > 0 { + for _, msg := range m.Id { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Value) > 0 { + for _, msg := range m.Value { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptNativeUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptNativeUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = *m.Field1 + i += 8 + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = *m.Field2 + i += 4 + } + if m.Field3 != nil { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field3)) + } + if m.Field4 != nil { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field4)) + } + if m.Field5 != nil { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field5)) + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptStructUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptStructUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = *m.Field1 + i += 8 + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = *m.Field2 + i += 4 + } + if m.Field3 != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3.Size())) + n52, err := m.Field3.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n52 + } + if m.Field4 != nil { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field4.Size())) + n53, err := m.Field4.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n53 + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinEmbeddedStructUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinEmbeddedStructUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NidOptNative != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.NidOptNative.Size())) + n54, err := m.NidOptNative.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n54 + } + if m.Field200 != nil { + data[i] = 0xc2 + i++ + data[i] = 0xc + i++ + i = encodeVarintThetest(data, i, uint64(m.Field200.Size())) + n55, err := m.Field200.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n55 + } + if m.Field210 != nil { + data[i] = 0x90 + i++ + data[i] = 0xd + i++ + if *m.Field210 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinNestedStructUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinNestedStructUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Field1.Size())) + n56, err := m.Field1.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n56 + } + if m.Field2 != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field2.Size())) + n57, err := m.Field2.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n57 + } + if m.Field3 != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Field3.Size())) + n58, err := m.Field3.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n58 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Tree) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Tree) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Or != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Or.Size())) + n59, err := m.Or.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n59 + } + if m.And != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.And.Size())) + n60, err := m.And.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n60 + } + if m.Leaf != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Leaf.Size())) + n61, err := m.Leaf.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n61 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *OrBranch) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *OrBranch) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Left.Size())) + n62, err := m.Left.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n62 + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Right.Size())) + n63, err := m.Right.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n63 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AndBranch) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AndBranch) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Left.Size())) + n64, err := m.Left.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n64 + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Right.Size())) + n65, err := m.Right.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n65 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Leaf) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Leaf) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(m.Value)) + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.StrValue))) + i += copy(data[i:], m.StrValue) + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *DeepTree) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *DeepTree) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Down != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Down.Size())) + n66, err := m.Down.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n66 + } + if m.And != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.And.Size())) + n67, err := m.And.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n67 + } + if m.Leaf != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.Leaf.Size())) + n68, err := m.Leaf.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n68 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *ADeepBranch) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *ADeepBranch) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Down.Size())) + n69, err := m.Down.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n69 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AndDeepBranch) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AndDeepBranch) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Left.Size())) + n70, err := m.Left.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n70 + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.Right.Size())) + n71, err := m.Right.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n71 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *DeepLeaf) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *DeepLeaf) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.Tree.Size())) + n72, err := m.Tree.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n72 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Nil) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Nil) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidOptEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidOptEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(m.Field1)) + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidRepEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidRepEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + for _, num := range m.Field1 { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptEnumDefault) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptEnumDefault) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AnotherNinOptEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AnotherNinOptEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AnotherNinOptEnumDefault) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AnotherNinOptEnumDefault) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Timer) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Timer) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x9 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = m.Time1 + i += 8 + data[i] = 0x11 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = m.Time2 + i += 8 + if m.Data != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Data))) + i += copy(data[i:], m.Data) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *MyExtendable) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *MyExtendable) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if len(m.XXX_extensions) > 0 { + n, err := github_com_gogo_protobuf_proto.EncodeExtensionMap(m.XXX_extensions, data[i:]) + if err != nil { + return 0, err + } + i += n + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *OtherExtenable) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *OtherExtenable) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.M != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.M.Size())) + n73, err := m.M.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n73 + } + if m.Field2 != nil { + data[i] = 0x10 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field2)) + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field13)) + } + if len(m.XXX_extensions) > 0 { + n, err := github_com_gogo_protobuf_proto.EncodeExtensionMap(m.XXX_extensions, data[i:]) + if err != nil { + return 0, err + } + i += n + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NestedDefinition) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NestedDefinition) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.EnumField != nil { + data[i] = 0x10 + i++ + i = encodeVarintThetest(data, i, uint64(*m.EnumField)) + } + if m.NNM != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.NNM.Size())) + n74, err := m.NNM.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n74 + } + if m.NM != nil { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(m.NM.Size())) + n75, err := m.NM.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n75 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NestedDefinition_NestedMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NestedDefinition_NestedMessage) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NestedField1 != nil { + data[i] = 0x9 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = *m.NestedField1 + i += 8 + } + if m.NNM != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.NNM.Size())) + n76, err := m.NNM.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n76 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NestedNestedField1 != nil { + data[i] = 0x52 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.NestedNestedField1))) + i += copy(data[i:], *m.NestedNestedField1) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NestedScope) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NestedScope) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.A != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.A.Size())) + n77, err := m.A.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n77 + } + if m.B != nil { + data[i] = 0x10 + i++ + i = encodeVarintThetest(data, i, uint64(*m.B)) + } + if m.C != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.C.Size())) + n78, err := m.C.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n78 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptNativeDefault) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptNativeDefault) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = *m.Field1 + i += 8 + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = *m.Field2 + i += 4 + } + if m.Field3 != nil { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field3)) + } + if m.Field4 != nil { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field4)) + } + if m.Field5 != nil { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field5)) + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field8 != nil { + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(*m.Field8)<<1)^uint64((*m.Field8>>63)))) + } + if m.Field9 != nil { + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = *m.Field9 + i += 4 + } + if m.Field10 != nil { + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = *m.Field10 + i += 4 + } + if m.Field11 != nil { + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = *m.Field11 + i += 8 + } + if m.Field12 != nil { + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = *m.Field12 + i += 8 + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomContainer) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomContainer) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.CustomStruct.Size())) + n79, err := m.CustomStruct.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n79 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNidOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNidOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = m.FieldA + i += 8 + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = m.FieldB + i += 4 + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldC)) + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldD)) + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldE)) + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldF)) + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(m.FieldG)<<1)^uint32((m.FieldG>>31)))) + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(m.FieldH)<<1)^uint64((m.FieldH>>63)))) + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = m.FieldI + i += 4 + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = m.FieldJ + i += 4 + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = m.FieldK + i += 8 + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = m.FieldL + i += 8 + data[i] = 0x68 + i++ + if m.FieldM { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(m.FieldN))) + i += copy(data[i:], m.FieldN) + if m.FieldO != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.FieldO))) + i += copy(data[i:], m.FieldO) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNinOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNinOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.FieldA != nil { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = *m.FieldA + i += 8 + } + if m.FieldB != nil { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = *m.FieldB + i += 4 + } + if m.FieldC != nil { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldC)) + } + if m.FieldD != nil { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldD)) + } + if m.FieldE != nil { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldE)) + } + if m.FieldF != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldF)) + } + if m.FieldG != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.FieldG)<<1)^uint32((*m.FieldG>>31)))) + } + if m.FieldH != nil { + data[i] = 0x40 + i++ + i = encodeVarintThetest(data, i, uint64((uint64(*m.FieldH)<<1)^uint64((*m.FieldH>>63)))) + } + if m.FieldI != nil { + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = *m.FieldI + i += 4 + } + if m.FieldJ != nil { + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = *m.FieldJ + i += 4 + } + if m.FieldK != nil { + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = *m.FieldK + i += 8 + } + if m.FielL != nil { + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = *m.FielL + i += 8 + } + if m.FieldM != nil { + data[i] = 0x68 + i++ + if *m.FieldM { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.FieldN != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.FieldN))) + i += copy(data[i:], *m.FieldN) + } + if m.FieldO != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.FieldO))) + i += copy(data[i:], m.FieldO) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNinRepNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNinRepNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.FieldA) > 0 { + for _, num := range m.FieldA { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.FieldB) > 0 { + for _, num := range m.FieldB { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.FieldC) > 0 { + for _, num := range m.FieldC { + data[i] = 0x18 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.FieldD) > 0 { + for _, num := range m.FieldD { + data[i] = 0x20 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.FieldE) > 0 { + for _, num := range m.FieldE { + data[i] = 0x28 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.FieldF) > 0 { + for _, num := range m.FieldF { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if len(m.FieldG) > 0 { + for _, num := range m.FieldG { + data[i] = 0x38 + i++ + x80 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x80 >= 1<<7 { + data[i] = uint8(uint64(x80)&0x7f | 0x80) + x80 >>= 7 + i++ + } + data[i] = uint8(x80) + i++ + } + } + if len(m.FieldH) > 0 { + for _, num := range m.FieldH { + data[i] = 0x40 + i++ + x81 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x81 >= 1<<7 { + data[i] = uint8(uint64(x81)&0x7f | 0x80) + x81 >>= 7 + i++ + } + data[i] = uint8(x81) + i++ + } + } + if len(m.FieldI) > 0 { + for _, num := range m.FieldI { + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.FieldJ) > 0 { + for _, num := range m.FieldJ { + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = num + i += 4 + } + } + if len(m.FieldK) > 0 { + for _, num := range m.FieldK { + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.FieldL) > 0 { + for _, num := range m.FieldL { + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = num + i += 8 + } + } + if len(m.FieldM) > 0 { + for _, b := range m.FieldM { + data[i] = 0x68 + i++ + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.FieldN) > 0 { + for _, s := range m.FieldN { + data[i] = 0x72 + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if len(m.FieldO) > 0 { + for _, b := range m.FieldO { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNinStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNinStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.FieldA != nil { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = *m.FieldA + i += 8 + } + if m.FieldB != nil { + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = *m.FieldB + i += 4 + } + if m.FieldC != nil { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldC.Size())) + n82, err := m.FieldC.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n82 + } + if len(m.FieldD) > 0 { + for _, msg := range m.FieldD { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.FieldE != nil { + data[i] = 0x30 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldE)) + } + if m.FieldF != nil { + data[i] = 0x38 + i++ + i = encodeVarintThetest(data, i, uint64((uint32(*m.FieldF)<<1)^uint32((*m.FieldF>>31)))) + } + if m.FieldG != nil { + data[i] = 0x42 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldG.Size())) + n83, err := m.FieldG.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n83 + } + if m.FieldH != nil { + data[i] = 0x68 + i++ + if *m.FieldH { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.FieldI != nil { + data[i] = 0x72 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.FieldI))) + i += copy(data[i:], *m.FieldI) + } + if m.FieldJ != nil { + data[i] = 0x7a + i++ + i = encodeVarintThetest(data, i, uint64(len(m.FieldJ))) + i += copy(data[i:], m.FieldJ) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameCustomType) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameCustomType) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.FieldA != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldA.Size())) + n84, err := m.FieldA.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n84 + } + if m.FieldB != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldB.Size())) + n85, err := m.FieldB.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n85 + } + if len(m.FieldC) > 0 { + for _, msg := range m.FieldC { + data[i] = 0x1a + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.FieldD) > 0 { + for _, msg := range m.FieldD { + data[i] = 0x22 + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameNinEmbeddedStructUnion) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameNinEmbeddedStructUnion) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NidOptNative != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.NidOptNative.Size())) + n86, err := m.NidOptNative.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n86 + } + if m.FieldA != nil { + data[i] = 0xc2 + i++ + data[i] = 0xc + i++ + i = encodeVarintThetest(data, i, uint64(m.FieldA.Size())) + n87, err := m.FieldA.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n87 + } + if m.FieldB != nil { + data[i] = 0x90 + i++ + data[i] = 0xd + i++ + if *m.FieldB { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomNameEnum) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomNameEnum) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.FieldA != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.FieldA)) + } + if len(m.FieldB) > 0 { + for _, num := range m.FieldB { + data[i] = 0x10 + i++ + i = encodeVarintThetest(data, i, uint64(num)) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NoExtensionsMap) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NoExtensionsMap) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + i += copy(data[i:], m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *Unrecognized) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Unrecognized) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field1))) + i += copy(data[i:], *m.Field1) + } + return i, nil +} + +func (m *UnrecognizedWithInner) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnrecognizedWithInner) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Embedded) > 0 { + for _, msg := range m.Embedded { + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.Field2 != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field2))) + i += copy(data[i:], *m.Field2) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *UnrecognizedWithInner_Inner) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnrecognizedWithInner_Inner) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + return i, nil +} + +func (m *UnrecognizedWithEmbed) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnrecognizedWithEmbed) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintThetest(data, i, uint64(m.UnrecognizedWithEmbed_Embedded.Size())) + n88, err := m.UnrecognizedWithEmbed_Embedded.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n88 + if m.Field2 != nil { + data[i] = 0x12 + i++ + i = encodeVarintThetest(data, i, uint64(len(*m.Field2))) + i += copy(data[i:], *m.Field2) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *UnrecognizedWithEmbed_Embedded) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnrecognizedWithEmbed_Embedded) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintThetest(data, i, uint64(*m.Field1)) + } + return i, nil +} + +func encodeFixed64Thetest(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Thetest(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintThetest(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafemarshaler/thetest.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafemarshaler/thetest.proto new file mode 100644 index 0000000000000000000000000000000000000000..f8fda9c30d72acab0c3d500c5a73a1ceee0703d6 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafemarshaler/thetest.proto @@ -0,0 +1,584 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package test; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = true; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message NidOptNative { + optional double Field1 = 1 [(gogoproto.nullable) = false]; + optional float Field2 = 2 [(gogoproto.nullable) = false]; + optional int32 Field3 = 3 [(gogoproto.nullable) = false]; + optional int64 Field4 = 4 [(gogoproto.nullable) = false]; + optional uint32 Field5 = 5 [(gogoproto.nullable) = false]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false]; + optional sint64 Field8 = 8 [(gogoproto.nullable) = false]; + optional fixed32 Field9 = 9 [(gogoproto.nullable) = false]; + optional sfixed32 Field10 = 10 [(gogoproto.nullable) = false]; + optional fixed64 Field11 = 11 [(gogoproto.nullable) = false]; + optional sfixed64 Field12 = 12 [(gogoproto.nullable) = false]; + optional bool Field13 = 13 [(gogoproto.nullable) = false]; + optional string Field14 = 14 [(gogoproto.nullable) = false]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinOptNative { + optional double Field1 = 1; + optional float Field2 = 2; + optional int32 Field3 = 3; + optional int64 Field4 = 4; + optional uint32 Field5 = 5; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional sint64 Field8 = 8; + optional fixed32 Field9 = 9; + optional sfixed32 Field10 = 10; + optional fixed64 Field11 = 11; + optional sfixed64 Field12 = 12; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NidRepNative { + repeated double Field1 = 1 [(gogoproto.nullable) = false]; + repeated float Field2 = 2 [(gogoproto.nullable) = false]; + repeated int32 Field3 = 3 [(gogoproto.nullable) = false]; + repeated int64 Field4 = 4 [(gogoproto.nullable) = false]; + repeated uint32 Field5 = 5 [(gogoproto.nullable) = false]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false]; + repeated sint64 Field8 = 8 [(gogoproto.nullable) = false]; + repeated fixed32 Field9 = 9 [(gogoproto.nullable) = false]; + repeated sfixed32 Field10 = 10 [(gogoproto.nullable) = false]; + repeated fixed64 Field11 = 11 [(gogoproto.nullable) = false]; + repeated sfixed64 Field12 = 12 [(gogoproto.nullable) = false]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false]; + repeated string Field14 = 14 [(gogoproto.nullable) = false]; + repeated bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinRepNative { + repeated double Field1 = 1; + repeated float Field2 = 2; + repeated int32 Field3 = 3; + repeated int64 Field4 = 4; + repeated uint32 Field5 = 5; + repeated uint64 Field6 = 6; + repeated sint32 Field7 = 7; + repeated sint64 Field8 = 8; + repeated fixed32 Field9 = 9; + repeated sfixed32 Field10 = 10; + repeated fixed64 Field11 = 11; + repeated sfixed64 Field12 = 12; + repeated bool Field13 = 13; + repeated string Field14 = 14; + repeated bytes Field15 = 15; +} + +message NidRepPackedNative { + repeated double Field1 = 1 [(gogoproto.nullable) = false, packed = true]; + repeated float Field2 = 2 [(gogoproto.nullable) = false, packed = true]; + repeated int32 Field3 = 3 [(gogoproto.nullable) = false, packed = true]; + repeated int64 Field4 = 4 [(gogoproto.nullable) = false, packed = true]; + repeated uint32 Field5 = 5 [(gogoproto.nullable) = false, packed = true]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false, packed = true]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false, packed = true]; + repeated sint64 Field8 = 8 [(gogoproto.nullable) = false, packed = true]; + repeated fixed32 Field9 = 9 [(gogoproto.nullable) = false, packed = true]; + repeated sfixed32 Field10 = 10 [(gogoproto.nullable) = false, packed = true]; + repeated fixed64 Field11 = 11 [(gogoproto.nullable) = false, packed = true]; + repeated sfixed64 Field12 = 12 [(gogoproto.nullable) = false, packed = true]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false, packed = true]; +} + +message NinRepPackedNative { + repeated double Field1 = 1 [packed = true]; + repeated float Field2 = 2 [packed = true]; + repeated int32 Field3 = 3 [packed = true]; + repeated int64 Field4 = 4 [packed = true]; + repeated uint32 Field5 = 5 [packed = true]; + repeated uint64 Field6 = 6 [packed = true]; + repeated sint32 Field7 = 7 [packed = true]; + repeated sint64 Field8 = 8 [packed = true]; + repeated fixed32 Field9 = 9 [packed = true]; + repeated sfixed32 Field10 = 10 [packed = true]; + repeated fixed64 Field11 = 11 [packed = true]; + repeated sfixed64 Field12 = 12 [packed = true]; + repeated bool Field13 = 13 [packed = true]; +} + +message NidOptStruct { + optional double Field1 = 1 [(gogoproto.nullable) = false]; + optional float Field2 = 2 [(gogoproto.nullable) = false]; + optional NidOptNative Field3 = 3 [(gogoproto.nullable) = false]; + optional NinOptNative Field4 = 4 [(gogoproto.nullable) = false]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false]; + optional NidOptNative Field8 = 8 [(gogoproto.nullable) = false]; + optional bool Field13 = 13 [(gogoproto.nullable) = false]; + optional string Field14 = 14 [(gogoproto.nullable) = false]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinOptStruct { + optional double Field1 = 1; + optional float Field2 = 2; + optional NidOptNative Field3 = 3; + optional NinOptNative Field4 = 4; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional NidOptNative Field8 = 8; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NidRepStruct { + repeated double Field1 = 1 [(gogoproto.nullable) = false]; + repeated float Field2 = 2 [(gogoproto.nullable) = false]; + repeated NidOptNative Field3 = 3 [(gogoproto.nullable) = false]; + repeated NinOptNative Field4 = 4 [(gogoproto.nullable) = false]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false]; + repeated NidOptNative Field8 = 8 [(gogoproto.nullable) = false]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false]; + repeated string Field14 = 14 [(gogoproto.nullable) = false]; + repeated bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinRepStruct { + repeated double Field1 = 1; + repeated float Field2 = 2; + repeated NidOptNative Field3 = 3; + repeated NinOptNative Field4 = 4; + repeated uint64 Field6 = 6; + repeated sint32 Field7 = 7; + repeated NidOptNative Field8 = 8; + repeated bool Field13 = 13; + repeated string Field14 = 14; + repeated bytes Field15 = 15; +} + +message NidEmbeddedStruct { + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NidOptNative Field200 = 200 [(gogoproto.nullable) = false]; + optional bool Field210 = 210 [(gogoproto.nullable) = false]; +} + +message NinEmbeddedStruct { + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NidOptNative Field200 = 200; + optional bool Field210 = 210; +} + +message NidNestedStruct { + optional NidOptStruct Field1 = 1 [(gogoproto.nullable) = false]; + repeated NidRepStruct Field2 = 2 [(gogoproto.nullable) = false]; +} + +message NinNestedStruct { + optional NinOptStruct Field1 = 1; + repeated NinRepStruct Field2 = 2; +} + +message NidOptCustom { + optional bytes Id = 1 [(gogoproto.customtype) = "Uuid", (gogoproto.nullable) = false]; + optional bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; +} + +message CustomDash { + optional bytes Value = 1 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom-dash-type.Bytes"]; +} + +message NinOptCustom { + optional bytes Id = 1 [(gogoproto.customtype) = "Uuid"]; + optional bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message NidRepCustom { + repeated bytes Id = 1 [(gogoproto.customtype) = "Uuid", (gogoproto.nullable) = false]; + repeated bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; +} + +message NinRepCustom { + repeated bytes Id = 1 [(gogoproto.customtype) = "Uuid"]; + repeated bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message NinOptNativeUnion { + option (gogoproto.onlyone) = true; + optional double Field1 = 1; + optional float Field2 = 2; + optional int32 Field3 = 3; + optional int64 Field4 = 4; + optional uint32 Field5 = 5; + optional uint64 Field6 = 6; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NinOptStructUnion { + option (gogoproto.onlyone) = true; + optional double Field1 = 1; + optional float Field2 = 2; + optional NidOptNative Field3 = 3; + optional NinOptNative Field4 = 4; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NinEmbeddedStructUnion { + option (gogoproto.onlyone) = true; + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NinOptNative Field200 = 200; + optional bool Field210 = 210; +} + +message NinNestedStructUnion { + option (gogoproto.onlyone) = true; + optional NinOptNativeUnion Field1 = 1; + optional NinOptStructUnion Field2 = 2; + optional NinEmbeddedStructUnion Field3 = 3; +} + +message Tree { + option (gogoproto.onlyone) = true; + optional OrBranch Or = 1; + optional AndBranch And = 2; + optional Leaf Leaf = 3; +} + +message OrBranch { + optional Tree Left = 1 [(gogoproto.nullable) = false]; + optional Tree Right = 2 [(gogoproto.nullable) = false]; +} + +message AndBranch { + optional Tree Left = 1 [(gogoproto.nullable) = false]; + optional Tree Right = 2 [(gogoproto.nullable) = false]; +} + +message Leaf { + optional int64 Value = 1 [(gogoproto.nullable) = false]; + optional string StrValue = 2 [(gogoproto.nullable) = false]; +} + +message DeepTree { + option (gogoproto.onlyone) = true; + optional ADeepBranch Down = 1; + optional AndDeepBranch And = 2; + optional DeepLeaf Leaf = 3; +} + +message ADeepBranch { + optional DeepTree Down = 2 [(gogoproto.nullable) = false]; +} + +message AndDeepBranch { + optional DeepTree Left = 1 [(gogoproto.nullable) = false]; + optional DeepTree Right = 2 [(gogoproto.nullable) = false]; +} + +message DeepLeaf { + optional Tree Tree = 1 [(gogoproto.nullable) = false]; +} + +message Nil { + +} + +enum TheTestEnum { + A = 0; + B = 1; + C = 2; +} + +message NidOptEnum { + optional TheTestEnum Field1 = 1 [(gogoproto.nullable) = false]; +} + +message NinOptEnum { + optional TheTestEnum Field1 = 1; +} + +message NidRepEnum { + repeated TheTestEnum Field1 = 1 [(gogoproto.nullable) = false]; +} + +message NinRepEnum { + repeated TheTestEnum Field1 = 1; +} + +message NinOptEnumDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional TheTestEnum Field1 = 1 [default=C]; +} + +enum AnotherTestEnum { + option (gogoproto.goproto_enum_prefix) = false; + D = 10; + E = 11; +} + +message AnotherNinOptEnum { + optional AnotherTestEnum Field1 = 1; +} + +message AnotherNinOptEnumDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional AnotherTestEnum Field1 = 1 [default=E]; +} + +message Timer { + optional sfixed64 Time1 = 1 [(gogoproto.nullable) = false]; + optional sfixed64 Time2 = 2 [(gogoproto.nullable) = false]; + optional bytes Data = 3 [(gogoproto.nullable) = false]; +} + +message MyExtendable { + option (gogoproto.face) = false; + optional int64 Field1 = 1; + extensions 100 to 199; +} + +extend MyExtendable { + optional double FieldA = 100; + optional NinOptNative FieldB = 101; + optional NinEmbeddedStruct FieldC = 102; +} + +message OtherExtenable { + option (gogoproto.face) = false; + optional int64 Field2 = 2; + extensions 14 to 16; + optional int64 Field13 = 13; + extensions 10 to 12; + optional MyExtendable M = 1; +} + +message NestedDefinition { + optional int64 Field1 = 1; + message NestedMessage { + optional fixed64 NestedField1 = 1; + optional NestedNestedMsg NNM = 2; + message NestedNestedMsg { + optional string NestedNestedField1 = 10; + } + } + enum NestedEnum { + TYPE_NESTED = 1; + } + optional NestedEnum EnumField = 2; + optional NestedMessage.NestedNestedMsg NNM = 3; + optional NestedMessage NM = 4; +} + +message NestedScope { + optional NestedDefinition.NestedMessage.NestedNestedMsg A = 1; + optional NestedDefinition.NestedEnum B = 2; + optional NestedDefinition.NestedMessage C = 3; +} + +message NinOptNativeDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional double Field1 = 1 [default = 1234.1234]; + optional float Field2 = 2 [default = 1234.1234]; + optional int32 Field3 = 3 [default = 1234]; + optional int64 Field4 = 4 [default = 1234]; + optional uint32 Field5 = 5 [default = 1234]; + optional uint64 Field6 = 6 [default = 1234]; + optional sint32 Field7 = 7 [default = 1234]; + optional sint64 Field8 = 8 [default = 1234]; + optional fixed32 Field9 = 9 [default = 1234]; + optional sfixed32 Field10 = 10 [default = 1234]; + optional fixed64 Field11 = 11 [default = 1234]; + optional sfixed64 Field12 = 12 [default = 1234]; + optional bool Field13 = 13 [default = true]; + optional string Field14 = 14 [default = "1234"]; + optional bytes Field15 = 15; +} + +message CustomContainer { + optional NidOptCustom CustomStruct = 1 [(gogoproto.nullable) = false]; +} + +message CustomNameNidOptNative { + optional double Field1 = 1 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldB"]; + optional int32 Field3 = 3 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldC"]; + optional int64 Field4 = 4 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldD"]; + optional uint32 Field5 = 5 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldE"]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldF"]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldG"]; + optional sint64 Field8 = 8 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldH"]; + optional fixed32 Field9 = 9 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldI"]; + optional sfixed32 Field10 = 10 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldJ"]; + optional fixed64 Field11 = 11 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldK"]; + optional sfixed64 Field12 = 12 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldL"]; + optional bool Field13 = 13 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldM"]; + optional string Field14 = 14 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldN"]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinOptNative { + optional double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + optional int32 Field3 = 3 [(gogoproto.customname) = "FieldC"]; + optional int64 Field4 = 4 [(gogoproto.customname) = "FieldD"]; + optional uint32 Field5 = 5 [(gogoproto.customname) = "FieldE"]; + optional uint64 Field6 = 6 [(gogoproto.customname) = "FieldF"]; + optional sint32 Field7 = 7 [(gogoproto.customname) = "FieldG"]; + optional sint64 Field8 = 8 [(gogoproto.customname) = "FieldH"]; + optional fixed32 Field9 = 9 [(gogoproto.customname) = "FieldI"]; + optional sfixed32 Field10 = 10 [(gogoproto.customname) = "FieldJ"]; + optional fixed64 Field11 = 11 [(gogoproto.customname) = "FieldK"]; + optional sfixed64 Field12 = 12 [(gogoproto.customname) = "FielL"]; + optional bool Field13 = 13 [(gogoproto.customname) = "FieldM"]; + optional string Field14 = 14 [(gogoproto.customname) = "FieldN"]; + optional bytes Field15 = 15 [(gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinRepNative { + repeated double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + repeated float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + repeated int32 Field3 = 3 [(gogoproto.customname) = "FieldC"]; + repeated int64 Field4 = 4 [(gogoproto.customname) = "FieldD"]; + repeated uint32 Field5 = 5 [(gogoproto.customname) = "FieldE"]; + repeated uint64 Field6 = 6 [(gogoproto.customname) = "FieldF"]; + repeated sint32 Field7 = 7 [(gogoproto.customname) = "FieldG"]; + repeated sint64 Field8 = 8 [(gogoproto.customname) = "FieldH"]; + repeated fixed32 Field9 = 9 [(gogoproto.customname) = "FieldI"]; + repeated sfixed32 Field10 = 10 [(gogoproto.customname) = "FieldJ"]; + repeated fixed64 Field11 = 11 [(gogoproto.customname) = "FieldK"]; + repeated sfixed64 Field12 = 12 [(gogoproto.customname) = "FieldL"]; + repeated bool Field13 = 13 [(gogoproto.customname) = "FieldM"]; + repeated string Field14 = 14 [(gogoproto.customname) = "FieldN"]; + repeated bytes Field15 = 15 [(gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinStruct { + optional double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + optional NidOptNative Field3 = 3 [(gogoproto.customname) = "FieldC"]; + repeated NinOptNative Field4 = 4 [(gogoproto.customname) = "FieldD"]; + optional uint64 Field6 = 6 [(gogoproto.customname) = "FieldE"]; + optional sint32 Field7 = 7 [(gogoproto.customname) = "FieldF"]; + optional NidOptNative Field8 = 8 [(gogoproto.customname) = "FieldG"]; + optional bool Field13 = 13 [(gogoproto.customname) = "FieldH"]; + optional string Field14 = 14 [(gogoproto.customname) = "FieldI"]; + optional bytes Field15 = 15 [(gogoproto.customname) = "FieldJ"]; +} + +message CustomNameCustomType { + optional bytes Id = 1 [(gogoproto.customname) = "FieldA", (gogoproto.customtype) = "Uuid"]; + optional bytes Value = 2 [(gogoproto.customname) = "FieldB", (gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; + repeated bytes Ids = 3 [(gogoproto.customname) = "FieldC", (gogoproto.customtype) = "Uuid"]; + repeated bytes Values = 4 [(gogoproto.customname) = "FieldD", (gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message CustomNameNinEmbeddedStructUnion { + option (gogoproto.onlyone) = true; + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NinOptNative Field200 = 200 [(gogoproto.customname) = "FieldA"]; + optional bool Field210 = 210 [(gogoproto.customname) = "FieldB"]; +} + +message CustomNameEnum { + optional TheTestEnum Field1 = 1 [(gogoproto.customname) = "FieldA"]; + repeated TheTestEnum Field2 = 2 [(gogoproto.customname) = "FieldB"]; +} + +message NoExtensionsMap { + option (gogoproto.face) = false; + option (gogoproto.goproto_extensions_map) = false; + optional int64 Field1 = 1; + extensions 100 to 199; +} + +extend NoExtensionsMap { + optional double FieldA1 = 100; + optional NinOptNative FieldB1 = 101; + optional NinEmbeddedStruct FieldC1 = 102; +} + +message Unrecognized { + option (gogoproto.goproto_unrecognized) = false; + optional string Field1 = 1; +} + +message UnrecognizedWithInner { + message Inner { + option (gogoproto.goproto_unrecognized) = false; + optional uint32 Field1 = 1; + } + + repeated Inner embedded = 1; + optional string Field2 = 2; +} + +message UnrecognizedWithEmbed { + message Embedded { + option (gogoproto.goproto_unrecognized) = false; + optional uint32 Field1 = 1; + } + + optional Embedded embedded = 1 [(gogoproto.embed) = true, (gogoproto.nullable) = false]; + optional string Field2 = 2; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafemarshaler/thetestpb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafemarshaler/thetestpb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..206aaea1b646832de4b079015cd6ef3939d6be57 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafemarshaler/thetestpb_test.go @@ -0,0 +1,14647 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafemarshaler/thetest.proto +// DO NOT EDIT! + +/* +Package test is a generated protocol buffer package. + +It is generated from these files: + combos/unsafemarshaler/thetest.proto + +It has these top-level messages: + NidOptNative + NinOptNative + NidRepNative + NinRepNative + NidRepPackedNative + NinRepPackedNative + NidOptStruct + NinOptStruct + NidRepStruct + NinRepStruct + NidEmbeddedStruct + NinEmbeddedStruct + NidNestedStruct + NinNestedStruct + NidOptCustom + CustomDash + NinOptCustom + NidRepCustom + NinRepCustom + NinOptNativeUnion + NinOptStructUnion + NinEmbeddedStructUnion + NinNestedStructUnion + Tree + OrBranch + AndBranch + Leaf + DeepTree + ADeepBranch + AndDeepBranch + DeepLeaf + Nil + NidOptEnum + NinOptEnum + NidRepEnum + NinRepEnum + NinOptEnumDefault + AnotherNinOptEnum + AnotherNinOptEnumDefault + Timer + MyExtendable + OtherExtenable + NestedDefinition + NestedScope + NinOptNativeDefault + CustomContainer + CustomNameNidOptNative + CustomNameNinOptNative + CustomNameNinRepNative + CustomNameNinStruct + CustomNameCustomType + CustomNameNinEmbeddedStructUnion + CustomNameEnum + NoExtensionsMap + Unrecognized + UnrecognizedWithInner + UnrecognizedWithEmbed +*/ +package test + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestNidOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidOptNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepPackedNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepPackedNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepPackedNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepPackedNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepPackedNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepPackedNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepPackedNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepPackedNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepPackedNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepPackedNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepPackedNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepPackedNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepPackedNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepPackedNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidOptStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidOptStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidEmbeddedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidEmbeddedStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidEmbeddedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidEmbeddedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidEmbeddedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidEmbeddedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidEmbeddedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinEmbeddedStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinEmbeddedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinEmbeddedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinEmbeddedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidNestedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidNestedStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidNestedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidNestedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidNestedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidNestedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidNestedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinNestedStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinNestedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinNestedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinNestedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidOptCustomMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidOptCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomDashProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomDashMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomDashProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomDash, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomDash(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomDashProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomDash(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomDash{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptCustomMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepCustomMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepCustomMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptNativeUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptNativeUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNativeUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNativeUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptStructUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinEmbeddedStructUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinEmbeddedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinEmbeddedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinNestedStructUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinNestedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinNestedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinNestedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinNestedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestTreeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestTreeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkTreeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Tree, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkTreeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTree(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Tree{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestOrBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestOrBranchMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkOrBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OrBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedOrBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkOrBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOrBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &OrBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAndBranchMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAndBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAndBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAndBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AndBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestLeafProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestLeafMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkLeafProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Leaf, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkLeafProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLeaf(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Leaf{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepTreeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestDeepTreeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkDeepTreeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepTree, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedDeepTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkDeepTreeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepTree(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &DeepTree{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestADeepBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestADeepBranchMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkADeepBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*ADeepBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedADeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkADeepBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedADeepBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &ADeepBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndDeepBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAndDeepBranchMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAndDeepBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndDeepBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAndDeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAndDeepBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndDeepBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AndDeepBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepLeafProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestDeepLeafMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkDeepLeafProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepLeaf, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedDeepLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkDeepLeafProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepLeaf(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &DeepLeaf{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNilProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNilMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNilProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nil, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNil(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNilProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNil(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Nil{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidOptEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNidRepEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinRepEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptEnumDefaultMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptEnumDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnumDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptEnumDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnumDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptEnumDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAnotherNinOptEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAnotherNinOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAnotherNinOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AnotherNinOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAnotherNinOptEnumDefaultMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAnotherNinOptEnumDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnumDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAnotherNinOptEnumDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnumDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AnotherNinOptEnumDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestTimerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestTimerMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkTimerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Timer, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedTimer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkTimerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTimer(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Timer{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMyExtendableProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestMyExtendableMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkMyExtendableProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MyExtendable, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMyExtendable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMyExtendableProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMyExtendable(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &MyExtendable{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestOtherExtenableProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestOtherExtenableMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkOtherExtenableProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OtherExtenable, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedOtherExtenable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkOtherExtenableProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOtherExtenable(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &OtherExtenable{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinitionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedDefinitionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedDefinitionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinitionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessageProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedDefinition_NestedMessageMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedDefinition_NestedMessageProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinition_NestedMessageProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition_NestedMessage{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedScopeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedScopeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedScopeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedScope, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedScope(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedScopeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedScope(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedScope{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptNativeDefaultMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNinOptNativeDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNativeDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNativeDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomContainerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomContainerMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomContainerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomContainer, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomContainer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomContainerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomContainer(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomContainer{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNidOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNidOptNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNidOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNidOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNidOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNidOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNidOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNinOptNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNinOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNinRepNativeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNinRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNinStructMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNinStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameCustomTypeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameCustomTypeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameCustomTypeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameCustomType, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameCustomType(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameCustomTypeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameCustomType(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameCustomType{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinEmbeddedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameNinEmbeddedStructUnionMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameNinEmbeddedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinEmbeddedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinEmbeddedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomNameEnumMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCustomNameEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNoExtensionsMapProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNoExtensionsMapMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNoExtensionsMapProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NoExtensionsMap, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNoExtensionsMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNoExtensionsMapProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNoExtensionsMap(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NoExtensionsMap{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Unrecognized, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognized(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognized(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Unrecognized{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInnerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedWithInnerMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedWithInnerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithInnerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithInner{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInner_InnerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedWithInner_InnerMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedWithInner_InnerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner_Inner, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithInner_InnerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner_Inner(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithInner_Inner{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedWithEmbedMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedWithEmbedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithEmbedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithEmbed{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbed_EmbeddedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed_Embedded, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithEmbed_Embedded{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepPackedNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepPackedNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidEmbeddedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinEmbeddedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidNestedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinNestedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomDashJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinEmbeddedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinNestedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTreeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOrBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAndBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestLeafJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestDeepTreeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestADeepBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAndDeepBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestDeepLeafJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNilJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptEnumDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAnotherNinOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAnotherNinOptEnumDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTimerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMyExtendableJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOtherExtenableJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinitionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinition_NestedMessageJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedScopeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomContainerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNidOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameCustomTypeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNoExtensionsMapJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithInnerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithInner_InnerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithEmbedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithEmbed_EmbeddedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepPackedNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepPackedNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepPackedNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepPackedNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidEmbeddedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidEmbeddedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidNestedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidNestedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomDashProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomDashProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTreeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTreeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOrBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOrBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestLeafProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestLeafProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepTreeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepTreeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestADeepBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestADeepBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndDeepBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndDeepBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepLeafProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepLeafProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNilProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNilProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTimerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTimerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMyExtendableProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMyExtendableProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOtherExtenableProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOtherExtenableProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinitionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinitionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessageProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessageProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedScopeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedScopeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomContainerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomContainerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNidOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNidOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameCustomTypeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameCustomTypeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinEmbeddedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinEmbeddedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNoExtensionsMapProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNoExtensionsMapProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInnerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInnerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInner_InnerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInner_InnerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestThetestDescription(t *testing.T) { + ThetestDescription() +} +func TestNidOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepPackedNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepPackedNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidEmbeddedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinEmbeddedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidNestedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinNestedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomDashVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinNestedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTreeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOrBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAndBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestLeafVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestDeepTreeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestADeepBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAndDeepBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestDeepLeafVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNilVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptEnumDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAnotherNinOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAnotherNinOptEnumDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTimerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMyExtendableVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOtherExtenableVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinitionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinition_NestedMessageVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedScopeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomContainerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNidOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameCustomTypeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNoExtensionsMapVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithInnerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithInner_InnerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithEmbedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithEmbed_EmbeddedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepPackedNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepPackedNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidEmbeddedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidNestedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinNestedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomDashFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptNativeUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinNestedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestTreeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestOrBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAndBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestLeafFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestDeepTreeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestADeepBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAndDeepBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestDeepLeafFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNilFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAnotherNinOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestTimerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinitionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinition_NestedMessageFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedScopeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomContainerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNidOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameCustomTypeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithInnerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithInner_InnerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithEmbedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithEmbed_EmbeddedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepPackedNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepPackedNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidEmbeddedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinEmbeddedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidNestedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinNestedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomDashGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinEmbeddedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinNestedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTreeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOrBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAndBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestLeafGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestDeepTreeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestADeepBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAndDeepBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestDeepLeafGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNilGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptEnumDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAnotherNinOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAnotherNinOptEnumDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTimerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMyExtendableGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOtherExtenableGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinitionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinition_NestedMessageGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedScopeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomContainerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNidOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameCustomTypeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinEmbeddedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNoExtensionsMapGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithInnerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithInner_InnerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithEmbedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithEmbed_EmbeddedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepPackedNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepPackedNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepPackedNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepPackedNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepPackedNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepPackedNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidEmbeddedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidEmbeddedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidEmbeddedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinEmbeddedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidNestedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidNestedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidNestedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinNestedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomDashSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomDashSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomDash, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomDash(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNativeUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinEmbeddedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinNestedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinNestedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestTreeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkTreeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Tree, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestOrBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkOrBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OrBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedOrBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAndBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAndBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestLeafSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkLeafSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Leaf, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepTreeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkDeepTreeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepTree, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedDeepTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestADeepBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkADeepBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*ADeepBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedADeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndDeepBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAndDeepBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndDeepBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAndDeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepLeafSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkDeepLeafSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepLeaf, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedDeepLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNilSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNilSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nil, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNil(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptEnumDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnumDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAnotherNinOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAnotherNinOptEnumDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnumDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestTimerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkTimerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Timer, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedTimer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMyExtendableSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMyExtendableSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MyExtendable, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMyExtendable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestOtherExtenableSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkOtherExtenableSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OtherExtenable, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedOtherExtenable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinitionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinitionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessageSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinition_NestedMessageSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedScopeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedScopeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedScope, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedScope(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNativeDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomContainerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomContainerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomContainer, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomContainer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNidOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNidOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNidOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameCustomTypeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameCustomTypeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameCustomType, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameCustomType(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinEmbeddedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinEmbeddedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinEmbeddedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNoExtensionsMapSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNoExtensionsMapSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NoExtensionsMap, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNoExtensionsMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Unrecognized, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognized(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInnerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithInnerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInner_InnerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithInner_InnerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner_Inner, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithEmbedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbed_EmbeddedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed_Embedded, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepPackedNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepPackedNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidEmbeddedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinEmbeddedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidNestedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinNestedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomDashStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinEmbeddedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinNestedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTreeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOrBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAndBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestLeafStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestDeepTreeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestADeepBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAndDeepBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestDeepLeafStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNilStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptEnumDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAnotherNinOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAnotherNinOptEnumDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTimerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestMyExtendableStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOtherExtenableStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinitionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinition_NestedMessageStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedScopeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomContainerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNidOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameCustomTypeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinEmbeddedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNoExtensionsMapStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithInnerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithInner_InnerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithEmbedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithEmbed_EmbeddedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, true) + v := p.GetValue() + msg := &NinOptNativeUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinOptStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, true) + v := p.GetValue() + msg := &NinOptStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + v := p.GetValue() + msg := &NinEmbeddedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinNestedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, true) + v := p.GetValue() + msg := &NinNestedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestTreeOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, true) + v := p.GetValue() + msg := &Tree{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestDeepTreeOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, true) + v := p.GetValue() + msg := &DeepTree{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + v := p.GetValue() + msg := &CustomNameNinEmbeddedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafemarshaler/uuid.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafemarshaler/uuid.go new file mode 100644 index 0000000000000000000000000000000000000000..4c071114bcce237893cd1f0fa4baca9d8663b571 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafemarshaler/uuid.go @@ -0,0 +1,122 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 test + +import ( + "bytes" + "encoding/json" +) + +func PutLittleEndianUint64(b []byte, offset int, v uint64) { + b[offset] = byte(v) + b[offset+1] = byte(v >> 8) + b[offset+2] = byte(v >> 16) + b[offset+3] = byte(v >> 24) + b[offset+4] = byte(v >> 32) + b[offset+5] = byte(v >> 40) + b[offset+6] = byte(v >> 48) + b[offset+7] = byte(v >> 56) +} + +type Uuid []byte + +func (uuid Uuid) Marshal() ([]byte, error) { + if len(uuid) == 0 { + return nil, nil + } + return []byte(uuid), nil +} + +func (uuid Uuid) MarshalTo(data []byte) (n int, err error) { + if len(uuid) == 0 { + return 0, nil + } + copy(data, uuid) + return 16, nil +} + +func (uuid *Uuid) Unmarshal(data []byte) error { + if len(data) == 0 { + uuid = nil + return nil + } + id := Uuid(make([]byte, 16)) + copy(id, data) + *uuid = id + return nil +} + +func (uuid *Uuid) Size() int { + if uuid == nil { + return 0 + } + if len(*uuid) == 0 { + return 0 + } + return 16 +} + +func (uuid Uuid) MarshalJSON() ([]byte, error) { + return json.Marshal([]byte(uuid)) +} + +func (uuid *Uuid) UnmarshalJSON(data []byte) error { + v := new([]byte) + err := json.Unmarshal(data, v) + if err != nil { + return err + } + return uuid.Unmarshal(*v) +} + +func (uuid Uuid) Equal(other Uuid) bool { + return bytes.Equal(uuid[0:], other[0:]) +} + +type int63 interface { + Int63() int64 +} + +func NewPopulatedUuid(r int63) *Uuid { + u := RandV4(r) + return &u +} + +func RandV4(r int63) Uuid { + uuid := make(Uuid, 16) + uuid.RandV4(r) + return uuid +} + +func (uuid Uuid) RandV4(r int63) { + PutLittleEndianUint64(uuid, 0, uint64(r.Int63())) + PutLittleEndianUint64(uuid, 8, uint64(r.Int63())) + uuid[6] = (uuid[6] & 0xf) | 0x40 + uuid[8] = (uuid[8] & 0x3f) | 0x80 +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeunmarshaler/bug_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeunmarshaler/bug_test.go new file mode 100644 index 0000000000000000000000000000000000000000..264d3982327d7276cc42c9314074f391dde60dfa --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeunmarshaler/bug_test.go @@ -0,0 +1,186 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 test + +import ( + "fmt" + "math" + "testing" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +) + +//http://code.google.com/p/goprotobuf/issues/detail?id=39 +func TestBugUint32VarintSize(t *testing.T) { + temp := uint32(math.MaxUint32) + n := &NinOptNative{} + n.Field5 = &temp + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != 6 { + t.Fatalf("data should be length 6, but its %#v", data) + } +} + +func TestBugZeroLengthSliceSize(t *testing.T) { + n := &NinRepPackedNative{ + Field8: []int64{}, + } + size := n.Size() + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != size { + t.Fatalf("expected %v, but got %v", len(data), size) + } +} + +//http://code.google.com/p/goprotobuf/issues/detail?id=40 +func TestBugPackedProtoSize(t *testing.T) { + n := &NinRepPackedNative{ + Field4: []int64{172960727389894724, 2360337516664475010, 860833876131988189, 9068073014890763245, 7794843386260381831, 4023536436053141786, 8992311247496919020, 4330096163611305776, 4490411416244976467, 7873947349172707443, 2754969595834279669, 1360667855926938684, 4771480785172657389, 4875578924966668055, 8070579869808877481, 9128179594766551001, 4630419407064527516, 863844540220372892, 8208727650143073487, 7086117356301045838, 7779695211931506151, 5493835345187563535, 9119767633370806007, 9054342025895349248, 1887303228838508438, 7624573031734528281, 1874668389749611225, 3517684643468970593, 6677697606628877758, 7293473953189936168, 444475066704085538, 8594971141363049302, 1146643249094989673, 733393306232853371, 7721178528893916886, 7784452000911004429, 6436373110242711440, 6897422461738321237, 8772249155667732778, 6211871464311393541, 3061903718310406883, 7845488913176136641, 8342255034663902574, 3443058984649725748, 8410801047334832902, 7496541071517841153, 4305416923521577765, 7814967600020476457, 8671843803465481186, 3490266370361096855, 1447425664719091336, 653218597262334239, 8306243902880091940, 7851896059762409081, 5936760560798954978, 5755724498441478025, 7022701569985035966, 3707709584811468220, 529069456924666920, 7986469043681522462, 3092513330689518836, 5103541550470476202, 3577384161242626406, 3733428084624703294, 8388690542440473117, 3262468785346149388, 8788358556558007570, 5476276940198542020, 7277903243119461239, 5065861426928605020, 7533460976202697734, 1749213838654236956, 557497603941617931, 5496307611456481108, 6444547750062831720, 6992758776744205596, 7356719693428537399, 2896328872476734507, 381447079530132038, 598300737753233118, 3687980626612697715, 7240924191084283349, 8172414415307971170, 4847024388701257185, 2081764168600256551, 3394217778539123488, 6244660626429310923, 8301712215675381614, 5360615125359461174, 8410140945829785773, 3152963269026381373, 6197275282781459633, 4419829061407546410, 6262035523070047537, 2837207483933463885, 2158105736666826128, 8150764172235490711}, + Field7: []int32{249451845, 1409974015, 393609128, 435232428, 1817529040, 91769006, 861170933, 1556185603, 1568580279, 1236375273, 512276621, 693633711, 967580535, 1950715977, 853431462, 1362390253, 159591204, 111900629, 322985263, 279671129, 1592548430, 465651370, 733849989, 1172059400, 1574824441, 263541092, 1271612397, 1520584358, 467078791, 117698716, 1098255064, 2054264846, 1766452305, 1267576395, 1557505617, 1187833560, 956187431, 1970977586, 1160235159, 1610259028, 489585797, 459139078, 566263183, 954319278, 1545018565, 1753946743, 948214318, 422878159, 883926576, 1424009347, 824732372, 1290433180, 80297942, 417294230, 1402647904, 2078392782, 220505045, 787368129, 463781454, 293083578, 808156928, 293976361}, + Field9: []uint32{0xaa4976e8, 0x3da8cc4c, 0x8c470d83, 0x344d964e, 0x5b90925, 0xa4c4d34e, 0x666eff19, 0xc238e552, 0x9be53bb6, 0x56364245, 0x33ee079d, 0x96bf0ede, 0x7941b74f, 0xdb07cb47, 0x6d76d827, 0x9b211d5d, 0x2798adb6, 0xe48b0c3b, 0x87061b21, 0x48f4e4d2, 0x3e5d5c12, 0x5ee91288, 0x336d4f35, 0xe1d44941, 0xc065548d, 0x2953d73f, 0x873af451, 0xfc769db, 0x9f1bf8da, 0x9baafdfc, 0xf1d3d770, 0x5bb5d2b4, 0xc2c67c48, 0x6845c4c1, 0xa48f32b0, 0xbb04bb70, 0xa5b1ca36, 0x8d98356a, 0x2171f654, 0x5ae279b0, 0x6c4a3d6b, 0x4fff5468, 0xcf9bf851, 0x68513614, 0xdbecd9b0, 0x9553ed3c, 0xa494a736, 0x42205438, 0xbf8e5caa, 0xd3283c6, 0x76d20788, 0x9179826f, 0x96b24f85, 0xbc2eacf4, 0xe4afae0b, 0x4bca85cb, 0x35e63b5b, 0xd7ccee0c, 0x2b506bb9, 0xe78e9f44, 0x9ad232f1, 0x99a37335, 0xa5d6ffc8}, + Field11: []uint64{0x53c01ebc, 0x4fb85ba6, 0x8805eea1, 0xb20ec896, 0x93b63410, 0xec7c9492, 0x50765a28, 0x19592106, 0x2ecc59b3, 0x39cd474f, 0xe4c9e47, 0x444f48c5, 0xe7731d32, 0xf3f43975, 0x603caedd, 0xbb05a1af, 0xa808e34e, 0x88580b07, 0x4c96bbd1, 0x730b4ab9, 0xed126e2b, 0x6db48205, 0x154ba1b9, 0xc26bfb6a, 0x389aa052, 0x869d966c, 0x7c86b366, 0xcc8edbcd, 0xfa8d6dad, 0xcf5857d9, 0x2d9cda0f, 0x1218a0b8, 0x41bf997, 0xf0ca65ac, 0xa610d4b9, 0x8d362e28, 0xb7212d87, 0x8e0fe109, 0xbee041d9, 0x759be2f6, 0x35fef4f3, 0xaeacdb71, 0x10888852, 0xf4e28117, 0xe2a14812, 0x73b748dc, 0xd1c3c6b2, 0xfef41bf0, 0xc9b43b62, 0x810e4faa, 0xcaa41c06, 0x1893fe0d, 0xedc7c850, 0xd12b9eaa, 0x467ee1a9, 0xbe84756b, 0xda7b1680, 0xdc069ffe, 0xf1e7e9f9, 0xb3d95370, 0xa92b77df, 0x5693ac41, 0xd04b7287, 0x27aebf15, 0x837b316e, 0x4dbe2263, 0xbab70c67, 0x547dab21, 0x3c346c1f, 0xb8ef0e4e, 0xfe2d03ce, 0xe1d75955, 0xfec1306, 0xba35c23e, 0xb784ed04, 0x2a4e33aa, 0x7e19d09a, 0x3827c1fe, 0xf3a51561, 0xef765e2b, 0xb044256c, 0x62b322be, 0xf34d56be, 0xeb71b369, 0xffe1294f, 0x237fe8d0, 0x77a1473b, 0x239e1196, 0xdd19bf3d, 0x82c91fe1, 0x95361c57, 0xffea3f1b, 0x1a094c84}, + Field12: []int64{8308420747267165049, 3664160795077875961, 7868970059161834817, 7237335984251173739, 5254748003907196506, 3362259627111837480, 430460752854552122, 5119635556501066533, 1277716037866233522, 9185775384759813768, 833932430882717888, 7986528304451297640, 6792233378368656337, 2074207091120609721, 1788723326198279432, 7756514594746453657, 2283775964901597324, 3061497730110517191, 7733947890656120277, 626967303632386244, 7822928600388582821, 3489658753000061230, 168869995163005961, 248814782163480763, 477885608911386247, 4198422415674133867, 3379354662797976109, 9925112544736939, 1486335136459138480, 4561560414032850671, 1010864164014091267, 186722821683803084, 5106357936724819318, 1298160820191228988, 4675403242419953145, 7130634540106489752, 7101280006672440929, 7176058292431955718, 9109875054097770321, 6810974877085322872, 4736707874303993641, 8993135362721382187, 6857881554990254283, 3704748883307461680, 1099360832887634994, 5207691918707192633, 5984721695043995243}, + } + size := proto.Size(n) + data, err := proto.Marshal(n) + if err != nil { + panic(err) + } + if len(data) != size { + t.Fatalf("expected %v, but got %v diff is %v", len(data), size, len(data)-size) + } +} + +func testSize(m interface { + proto.Message + Size() int +}, desc string, expected int) ([]byte, error) { + data, err := proto.Marshal(m) + if err != nil { + return nil, err + } + protoSize := proto.Size(m) + mSize := m.Size() + lenData := len(data) + if protoSize != mSize || protoSize != lenData || mSize != lenData { + return nil, fmt.Errorf("%s proto.Size(m){%d} != m.Size(){%d} != len(data){%d}", desc, protoSize, mSize, lenData) + } + if got := protoSize; got != expected { + return nil, fmt.Errorf("%s proto.Size(m) got %d expected %d", desc, got, expected) + } + if got := mSize; got != expected { + return nil, fmt.Errorf("%s m.Size() got %d expected %d", desc, got, expected) + } + if got := lenData; got != expected { + return nil, fmt.Errorf("%s len(data) got %d expected %d", desc, got, expected) + } + return data, nil +} + +func TestInt32Int64Compatibility(t *testing.T) { + + //test nullable int32 and int64 + + data1, err := testSize(&NinOptNative{ + Field3: proto.Int32(-1), + }, "nullable", 11) + if err != nil { + t.Error(err) + } + //change marshaled data1 to unmarshal into 4th field which is an int64 + data1[0] = uint8(uint32(4 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + u1 := &NinOptNative{} + if err := proto.Unmarshal(data1, u1); err != nil { + t.Error(err) + } + if !u1.Equal(&NinOptNative{ + Field4: proto.Int64(-1), + }) { + t.Error("nullable unmarshaled int32 is not the same int64") + } + + //test non-nullable int32 and int64 + + data2, err := testSize(&NidOptNative{ + Field3: -1, + }, "non nullable", 67) + if err != nil { + t.Error(err) + } + //change marshaled data2 to unmarshal into 4th field which is an int64 + field3 := uint8(uint32(3 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + field4 := uint8(uint32(4 /*fieldNumber*/)<<3 | uint32(0 /*wireType*/)) + for i, c := range data2 { + if c == field4 { + data2[i] = field3 + } else if c == field3 { + data2[i] = field4 + } + } + u2 := &NidOptNative{} + if err := proto.Unmarshal(data2, u2); err != nil { + t.Error(err) + } + if !u2.Equal(&NidOptNative{ + Field4: -1, + }) { + t.Error("non nullable unmarshaled int32 is not the same int64") + } + + //test packed repeated int32 and int64 + + m4 := &NinRepPackedNative{ + Field3: []int32{-1}, + } + data4, err := testSize(m4, "packed", 12) + if err != nil { + t.Error(err) + } + u4 := &NinRepPackedNative{} + if err := proto.Unmarshal(data4, u4); err != nil { + t.Error(err) + } + if err := u4.VerboseEqual(m4); err != nil { + t.Fatalf("%#v", u4) + } + + //test repeated int32 and int64 + + if _, err := testSize(&NinRepNative{ + Field3: []int32{-1}, + }, "repeated", 11); err != nil { + t.Error(err) + } + + t.Logf("tested all") +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeunmarshaler/thetest.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeunmarshaler/thetest.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..eb32dcc15dc91491fb43771bcd6336bab008350f --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeunmarshaler/thetest.pb.go @@ -0,0 +1,32552 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeunmarshaler/thetest.proto +// DO NOT EDIT! + +/* + Package test is a generated protocol buffer package. + + It is generated from these files: + combos/unsafeunmarshaler/thetest.proto + + It has these top-level messages: + NidOptNative + NinOptNative + NidRepNative + NinRepNative + NidRepPackedNative + NinRepPackedNative + NidOptStruct + NinOptStruct + NidRepStruct + NinRepStruct + NidEmbeddedStruct + NinEmbeddedStruct + NidNestedStruct + NinNestedStruct + NidOptCustom + CustomDash + NinOptCustom + NidRepCustom + NinRepCustom + NinOptNativeUnion + NinOptStructUnion + NinEmbeddedStructUnion + NinNestedStructUnion + Tree + OrBranch + AndBranch + Leaf + DeepTree + ADeepBranch + AndDeepBranch + DeepLeaf + Nil + NidOptEnum + NinOptEnum + NidRepEnum + NinRepEnum + NinOptEnumDefault + AnotherNinOptEnum + AnotherNinOptEnumDefault + Timer + MyExtendable + OtherExtenable + NestedDefinition + NestedScope + NinOptNativeDefault + CustomContainer + CustomNameNidOptNative + CustomNameNinOptNative + CustomNameNinRepNative + CustomNameNinStruct + CustomNameCustomType + CustomNameNinEmbeddedStructUnion + CustomNameEnum + NoExtensionsMap + Unrecognized + UnrecognizedWithInner + UnrecognizedWithEmbed +*/ +package test + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_custom "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom" +import github_com_gogo_protobuf_test_custom_dash_type "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom-dash-type" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" + +import io "io" +import unsafe "unsafe" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type TheTestEnum int32 + +const ( + A TheTestEnum = 0 + B TheTestEnum = 1 + C TheTestEnum = 2 +) + +var TheTestEnum_name = map[int32]string{ + 0: "A", + 1: "B", + 2: "C", +} +var TheTestEnum_value = map[string]int32{ + "A": 0, + "B": 1, + "C": 2, +} + +func (x TheTestEnum) Enum() *TheTestEnum { + p := new(TheTestEnum) + *p = x + return p +} +func (x TheTestEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(TheTestEnum_name, int32(x)) +} +func (x *TheTestEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(TheTestEnum_value, data, "TheTestEnum") + if err != nil { + return err + } + *x = TheTestEnum(value) + return nil +} + +type AnotherTestEnum int32 + +const ( + D AnotherTestEnum = 10 + E AnotherTestEnum = 11 +) + +var AnotherTestEnum_name = map[int32]string{ + 10: "D", + 11: "E", +} +var AnotherTestEnum_value = map[string]int32{ + "D": 10, + "E": 11, +} + +func (x AnotherTestEnum) Enum() *AnotherTestEnum { + p := new(AnotherTestEnum) + *p = x + return p +} +func (x AnotherTestEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(AnotherTestEnum_name, int32(x)) +} +func (x *AnotherTestEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(AnotherTestEnum_value, data, "AnotherTestEnum") + if err != nil { + return err + } + *x = AnotherTestEnum(value) + return nil +} + +type NestedDefinition_NestedEnum int32 + +const ( + TYPE_NESTED NestedDefinition_NestedEnum = 1 +) + +var NestedDefinition_NestedEnum_name = map[int32]string{ + 1: "TYPE_NESTED", +} +var NestedDefinition_NestedEnum_value = map[string]int32{ + "TYPE_NESTED": 1, +} + +func (x NestedDefinition_NestedEnum) Enum() *NestedDefinition_NestedEnum { + p := new(NestedDefinition_NestedEnum) + *p = x + return p +} +func (x NestedDefinition_NestedEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(NestedDefinition_NestedEnum_name, int32(x)) +} +func (x *NestedDefinition_NestedEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(NestedDefinition_NestedEnum_value, data, "NestedDefinition_NestedEnum") + if err != nil { + return err + } + *x = NestedDefinition_NestedEnum(value) + return nil +} + +type NidOptNative struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + Field3 int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3"` + Field4 int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4"` + Field5 uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5"` + Field6 uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8"` + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9"` + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10"` + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11"` + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12"` + Field13 bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + Field14 string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptNative) Reset() { *m = NidOptNative{} } +func (*NidOptNative) ProtoMessage() {} + +type NinOptNative struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"` + Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"` + Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"` + Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"` + Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNative) Reset() { *m = NinOptNative{} } +func (*NinOptNative) ProtoMessage() {} + +type NidRepNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepNative) Reset() { *m = NidRepNative{} } +func (*NidRepNative) ProtoMessage() {} + +type NinRepNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepNative) Reset() { *m = NinRepNative{} } +func (*NinRepNative) ProtoMessage() {} + +type NidRepPackedNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepPackedNative) Reset() { *m = NidRepPackedNative{} } +func (*NidRepPackedNative) ProtoMessage() {} + +type NinRepPackedNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepPackedNative) Reset() { *m = NinRepPackedNative{} } +func (*NinRepPackedNative) ProtoMessage() {} + +type NidOptStruct struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + Field3 NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3"` + Field4 NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4"` + Field6 uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + Field8 NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8"` + Field13 bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + Field14 string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptStruct) Reset() { *m = NidOptStruct{} } +func (*NidOptStruct) ProtoMessage() {} + +type NinOptStruct struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field8 *NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptStruct) Reset() { *m = NinOptStruct{} } +func (*NinOptStruct) ProtoMessage() {} + +type NidRepStruct struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []NidOptNative `protobuf:"bytes,3,rep,name=Field3" json:"Field3"` + Field4 []NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []NidOptNative `protobuf:"bytes,8,rep,name=Field8" json:"Field8"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepStruct) Reset() { *m = NidRepStruct{} } +func (*NidRepStruct) ProtoMessage() {} + +type NinRepStruct struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []*NidOptNative `protobuf:"bytes,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []*NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []*NidOptNative `protobuf:"bytes,8,rep,name=Field8" json:"Field8,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepStruct) Reset() { *m = NinRepStruct{} } +func (*NinRepStruct) ProtoMessage() {} + +type NidEmbeddedStruct struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 NidOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200"` + Field210 bool `protobuf:"varint,210,opt,name=Field210" json:"Field210"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidEmbeddedStruct) Reset() { *m = NidEmbeddedStruct{} } +func (*NidEmbeddedStruct) ProtoMessage() {} + +type NinEmbeddedStruct struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 *NidOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + Field210 *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinEmbeddedStruct) Reset() { *m = NinEmbeddedStruct{} } +func (*NinEmbeddedStruct) ProtoMessage() {} + +type NidNestedStruct struct { + Field1 NidOptStruct `protobuf:"bytes,1,opt,name=Field1" json:"Field1"` + Field2 []NidRepStruct `protobuf:"bytes,2,rep,name=Field2" json:"Field2"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidNestedStruct) Reset() { *m = NidNestedStruct{} } +func (*NidNestedStruct) ProtoMessage() {} + +type NinNestedStruct struct { + Field1 *NinOptStruct `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 []*NinRepStruct `protobuf:"bytes,2,rep,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinNestedStruct) Reset() { *m = NinNestedStruct{} } +func (*NinNestedStruct) ProtoMessage() {} + +type NidOptCustom struct { + Id Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id"` + Value github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptCustom) Reset() { *m = NidOptCustom{} } +func (*NidOptCustom) ProtoMessage() {} + +type CustomDash struct { + Value *github_com_gogo_protobuf_test_custom_dash_type.Bytes `protobuf:"bytes,1,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom-dash-type.Bytes" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomDash) Reset() { *m = CustomDash{} } +func (*CustomDash) ProtoMessage() {} + +type NinOptCustom struct { + Id *Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id,omitempty"` + Value *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptCustom) Reset() { *m = NinOptCustom{} } +func (*NinOptCustom) ProtoMessage() {} + +type NidRepCustom struct { + Id []Uuid `protobuf:"bytes,1,rep,name=Id,customtype=Uuid" json:"Id"` + Value []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepCustom) Reset() { *m = NidRepCustom{} } +func (*NidRepCustom) ProtoMessage() {} + +type NinRepCustom struct { + Id []Uuid `protobuf:"bytes,1,rep,name=Id,customtype=Uuid" json:"Id,omitempty"` + Value []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepCustom) Reset() { *m = NinRepCustom{} } +func (*NinRepCustom) ProtoMessage() {} + +type NinOptNativeUnion struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNativeUnion) Reset() { *m = NinOptNativeUnion{} } +func (*NinOptNativeUnion) ProtoMessage() {} + +type NinOptStructUnion struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptStructUnion) Reset() { *m = NinOptStructUnion{} } +func (*NinOptStructUnion) ProtoMessage() {} + +type NinEmbeddedStructUnion struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 *NinOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + Field210 *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinEmbeddedStructUnion) Reset() { *m = NinEmbeddedStructUnion{} } +func (*NinEmbeddedStructUnion) ProtoMessage() {} + +type NinNestedStructUnion struct { + Field1 *NinOptNativeUnion `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *NinOptStructUnion `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NinEmbeddedStructUnion `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinNestedStructUnion) Reset() { *m = NinNestedStructUnion{} } +func (*NinNestedStructUnion) ProtoMessage() {} + +type Tree struct { + Or *OrBranch `protobuf:"bytes,1,opt,name=Or" json:"Or,omitempty"` + And *AndBranch `protobuf:"bytes,2,opt,name=And" json:"And,omitempty"` + Leaf *Leaf `protobuf:"bytes,3,opt,name=Leaf" json:"Leaf,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Tree) Reset() { *m = Tree{} } +func (*Tree) ProtoMessage() {} + +type OrBranch struct { + Left Tree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right Tree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OrBranch) Reset() { *m = OrBranch{} } +func (*OrBranch) ProtoMessage() {} + +type AndBranch struct { + Left Tree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right Tree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AndBranch) Reset() { *m = AndBranch{} } +func (*AndBranch) ProtoMessage() {} + +type Leaf struct { + Value int64 `protobuf:"varint,1,opt,name=Value" json:"Value"` + StrValue string `protobuf:"bytes,2,opt,name=StrValue" json:"StrValue"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Leaf) Reset() { *m = Leaf{} } +func (*Leaf) ProtoMessage() {} + +type DeepTree struct { + Down *ADeepBranch `protobuf:"bytes,1,opt,name=Down" json:"Down,omitempty"` + And *AndDeepBranch `protobuf:"bytes,2,opt,name=And" json:"And,omitempty"` + Leaf *DeepLeaf `protobuf:"bytes,3,opt,name=Leaf" json:"Leaf,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeepTree) Reset() { *m = DeepTree{} } +func (*DeepTree) ProtoMessage() {} + +type ADeepBranch struct { + Down DeepTree `protobuf:"bytes,2,opt,name=Down" json:"Down"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ADeepBranch) Reset() { *m = ADeepBranch{} } +func (*ADeepBranch) ProtoMessage() {} + +type AndDeepBranch struct { + Left DeepTree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right DeepTree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AndDeepBranch) Reset() { *m = AndDeepBranch{} } +func (*AndDeepBranch) ProtoMessage() {} + +type DeepLeaf struct { + Tree Tree `protobuf:"bytes,1,opt,name=Tree" json:"Tree"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeepLeaf) Reset() { *m = DeepLeaf{} } +func (*DeepLeaf) ProtoMessage() {} + +type Nil struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *Nil) Reset() { *m = Nil{} } +func (*Nil) ProtoMessage() {} + +type NidOptEnum struct { + Field1 TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptEnum) Reset() { *m = NidOptEnum{} } +func (*NidOptEnum) ProtoMessage() {} + +type NinOptEnum struct { + Field1 *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptEnum) Reset() { *m = NinOptEnum{} } +func (*NinOptEnum) ProtoMessage() {} + +type NidRepEnum struct { + Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepEnum) Reset() { *m = NidRepEnum{} } +func (*NidRepEnum) ProtoMessage() {} + +type NinRepEnum struct { + Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepEnum) Reset() { *m = NinRepEnum{} } +func (*NinRepEnum) ProtoMessage() {} + +type NinOptEnumDefault struct { + Field1 *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum,def=2" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptEnumDefault) Reset() { *m = NinOptEnumDefault{} } +func (*NinOptEnumDefault) ProtoMessage() {} + +const Default_NinOptEnumDefault_Field1 TheTestEnum = C + +func (m *NinOptEnumDefault) GetField1() TheTestEnum { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_NinOptEnumDefault_Field1 +} + +type AnotherNinOptEnum struct { + Field1 *AnotherTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.AnotherTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AnotherNinOptEnum) Reset() { *m = AnotherNinOptEnum{} } +func (*AnotherNinOptEnum) ProtoMessage() {} + +type AnotherNinOptEnumDefault struct { + Field1 *AnotherTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.AnotherTestEnum,def=11" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AnotherNinOptEnumDefault) Reset() { *m = AnotherNinOptEnumDefault{} } +func (*AnotherNinOptEnumDefault) ProtoMessage() {} + +const Default_AnotherNinOptEnumDefault_Field1 AnotherTestEnum = E + +func (m *AnotherNinOptEnumDefault) GetField1() AnotherTestEnum { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_AnotherNinOptEnumDefault_Field1 +} + +type Timer struct { + Time1 int64 `protobuf:"fixed64,1,opt,name=Time1" json:"Time1"` + Time2 int64 `protobuf:"fixed64,2,opt,name=Time2" json:"Time2"` + Data []byte `protobuf:"bytes,3,opt,name=Data" json:"Data"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Timer) Reset() { *m = Timer{} } +func (*Timer) ProtoMessage() {} + +type MyExtendable struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MyExtendable) Reset() { *m = MyExtendable{} } +func (*MyExtendable) ProtoMessage() {} + +var extRange_MyExtendable = []proto.ExtensionRange{ + {100, 199}, +} + +func (*MyExtendable) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MyExtendable +} +func (m *MyExtendable) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type OtherExtenable struct { + Field2 *int64 `protobuf:"varint,2,opt,name=Field2" json:"Field2,omitempty"` + Field13 *int64 `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + M *MyExtendable `protobuf:"bytes,1,opt,name=M" json:"M,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OtherExtenable) Reset() { *m = OtherExtenable{} } +func (*OtherExtenable) ProtoMessage() {} + +var extRange_OtherExtenable = []proto.ExtensionRange{ + {14, 16}, + {10, 12}, +} + +func (*OtherExtenable) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_OtherExtenable +} +func (m *OtherExtenable) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type NestedDefinition struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + EnumField *NestedDefinition_NestedEnum `protobuf:"varint,2,opt,name=EnumField,enum=test.NestedDefinition_NestedEnum" json:"EnumField,omitempty"` + NNM *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,3,opt,name=NNM" json:"NNM,omitempty"` + NM *NestedDefinition_NestedMessage `protobuf:"bytes,4,opt,name=NM" json:"NM,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition) Reset() { *m = NestedDefinition{} } +func (*NestedDefinition) ProtoMessage() {} + +type NestedDefinition_NestedMessage struct { + NestedField1 *uint64 `protobuf:"fixed64,1,opt,name=NestedField1" json:"NestedField1,omitempty"` + NNM *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,2,opt,name=NNM" json:"NNM,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition_NestedMessage) Reset() { *m = NestedDefinition_NestedMessage{} } +func (*NestedDefinition_NestedMessage) ProtoMessage() {} + +type NestedDefinition_NestedMessage_NestedNestedMsg struct { + NestedNestedField1 *string `protobuf:"bytes,10,opt,name=NestedNestedField1" json:"NestedNestedField1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Reset() { + *m = NestedDefinition_NestedMessage_NestedNestedMsg{} +} +func (*NestedDefinition_NestedMessage_NestedNestedMsg) ProtoMessage() {} + +type NestedScope struct { + A *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,1,opt,name=A" json:"A,omitempty"` + B *NestedDefinition_NestedEnum `protobuf:"varint,2,opt,name=B,enum=test.NestedDefinition_NestedEnum" json:"B,omitempty"` + C *NestedDefinition_NestedMessage `protobuf:"bytes,3,opt,name=C" json:"C,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedScope) Reset() { *m = NestedScope{} } +func (*NestedScope) ProtoMessage() {} + +type NinOptNativeDefault struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1,def=1234.1234" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2,def=1234.1234" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3,def=1234" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4,def=1234" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5,def=1234" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6,def=1234" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7,def=1234" json:"Field7,omitempty"` + Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8,def=1234" json:"Field8,omitempty"` + Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9,def=1234" json:"Field9,omitempty"` + Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10,def=1234" json:"Field10,omitempty"` + Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11,def=1234" json:"Field11,omitempty"` + Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12,def=1234" json:"Field12,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13,def=1" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14,def=1234" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNativeDefault) Reset() { *m = NinOptNativeDefault{} } +func (*NinOptNativeDefault) ProtoMessage() {} + +const Default_NinOptNativeDefault_Field1 float64 = 1234.1234 +const Default_NinOptNativeDefault_Field2 float32 = 1234.1234 +const Default_NinOptNativeDefault_Field3 int32 = 1234 +const Default_NinOptNativeDefault_Field4 int64 = 1234 +const Default_NinOptNativeDefault_Field5 uint32 = 1234 +const Default_NinOptNativeDefault_Field6 uint64 = 1234 +const Default_NinOptNativeDefault_Field7 int32 = 1234 +const Default_NinOptNativeDefault_Field8 int64 = 1234 +const Default_NinOptNativeDefault_Field9 uint32 = 1234 +const Default_NinOptNativeDefault_Field10 int32 = 1234 +const Default_NinOptNativeDefault_Field11 uint64 = 1234 +const Default_NinOptNativeDefault_Field12 int64 = 1234 +const Default_NinOptNativeDefault_Field13 bool = true +const Default_NinOptNativeDefault_Field14 string = "1234" + +func (m *NinOptNativeDefault) GetField1() float64 { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_NinOptNativeDefault_Field1 +} + +func (m *NinOptNativeDefault) GetField2() float32 { + if m != nil && m.Field2 != nil { + return *m.Field2 + } + return Default_NinOptNativeDefault_Field2 +} + +func (m *NinOptNativeDefault) GetField3() int32 { + if m != nil && m.Field3 != nil { + return *m.Field3 + } + return Default_NinOptNativeDefault_Field3 +} + +func (m *NinOptNativeDefault) GetField4() int64 { + if m != nil && m.Field4 != nil { + return *m.Field4 + } + return Default_NinOptNativeDefault_Field4 +} + +func (m *NinOptNativeDefault) GetField5() uint32 { + if m != nil && m.Field5 != nil { + return *m.Field5 + } + return Default_NinOptNativeDefault_Field5 +} + +func (m *NinOptNativeDefault) GetField6() uint64 { + if m != nil && m.Field6 != nil { + return *m.Field6 + } + return Default_NinOptNativeDefault_Field6 +} + +func (m *NinOptNativeDefault) GetField7() int32 { + if m != nil && m.Field7 != nil { + return *m.Field7 + } + return Default_NinOptNativeDefault_Field7 +} + +func (m *NinOptNativeDefault) GetField8() int64 { + if m != nil && m.Field8 != nil { + return *m.Field8 + } + return Default_NinOptNativeDefault_Field8 +} + +func (m *NinOptNativeDefault) GetField9() uint32 { + if m != nil && m.Field9 != nil { + return *m.Field9 + } + return Default_NinOptNativeDefault_Field9 +} + +func (m *NinOptNativeDefault) GetField10() int32 { + if m != nil && m.Field10 != nil { + return *m.Field10 + } + return Default_NinOptNativeDefault_Field10 +} + +func (m *NinOptNativeDefault) GetField11() uint64 { + if m != nil && m.Field11 != nil { + return *m.Field11 + } + return Default_NinOptNativeDefault_Field11 +} + +func (m *NinOptNativeDefault) GetField12() int64 { + if m != nil && m.Field12 != nil { + return *m.Field12 + } + return Default_NinOptNativeDefault_Field12 +} + +func (m *NinOptNativeDefault) GetField13() bool { + if m != nil && m.Field13 != nil { + return *m.Field13 + } + return Default_NinOptNativeDefault_Field13 +} + +func (m *NinOptNativeDefault) GetField14() string { + if m != nil && m.Field14 != nil { + return *m.Field14 + } + return Default_NinOptNativeDefault_Field14 +} + +func (m *NinOptNativeDefault) GetField15() []byte { + if m != nil { + return m.Field15 + } + return nil +} + +type CustomContainer struct { + CustomStruct NidOptCustom `protobuf:"bytes,1,opt,name=CustomStruct" json:"CustomStruct"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomContainer) Reset() { *m = CustomContainer{} } +func (*CustomContainer) ProtoMessage() {} + +type CustomNameNidOptNative struct { + FieldA float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + FieldB float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + FieldC int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3"` + FieldD int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4"` + FieldE uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5"` + FieldF uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + FieldG int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + FieldH int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8"` + FieldI uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9"` + FieldJ int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10"` + FieldK uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11"` + FieldL int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12"` + FieldM bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + FieldN string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + FieldO []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNidOptNative) Reset() { *m = CustomNameNidOptNative{} } +func (*CustomNameNidOptNative) ProtoMessage() {} + +type CustomNameNinOptNative struct { + FieldA *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + FieldB *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + FieldC *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + FieldD *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + FieldE *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + FieldF *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + FieldG *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + FieldH *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"` + FieldI *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"` + FieldJ *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"` + FieldK *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"` + FielL *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"` + FieldM *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + FieldN *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + FieldO []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinOptNative) Reset() { *m = CustomNameNinOptNative{} } +func (*CustomNameNinOptNative) ProtoMessage() {} + +type CustomNameNinRepNative struct { + FieldA []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + FieldB []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + FieldC []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + FieldD []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + FieldE []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + FieldF []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + FieldG []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + FieldH []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + FieldI []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + FieldJ []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + FieldK []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + FieldL []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + FieldM []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + FieldN []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + FieldO [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinRepNative) Reset() { *m = CustomNameNinRepNative{} } +func (*CustomNameNinRepNative) ProtoMessage() {} + +type CustomNameNinStruct struct { + FieldA *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + FieldB *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + FieldC *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + FieldD []*NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4,omitempty"` + FieldE *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + FieldF *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + FieldG *NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"` + FieldH *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + FieldI *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + FieldJ []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinStruct) Reset() { *m = CustomNameNinStruct{} } +func (*CustomNameNinStruct) ProtoMessage() {} + +type CustomNameCustomType struct { + FieldA *Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id,omitempty"` + FieldB *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + FieldC []Uuid `protobuf:"bytes,3,rep,name=Ids,customtype=Uuid" json:"Ids,omitempty"` + FieldD []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,4,rep,name=Values,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Values,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameCustomType) Reset() { *m = CustomNameCustomType{} } +func (*CustomNameCustomType) ProtoMessage() {} + +type CustomNameNinEmbeddedStructUnion struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + FieldA *NinOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + FieldB *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinEmbeddedStructUnion) Reset() { *m = CustomNameNinEmbeddedStructUnion{} } +func (*CustomNameNinEmbeddedStructUnion) ProtoMessage() {} + +type CustomNameEnum struct { + FieldA *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + FieldB []TheTestEnum `protobuf:"varint,2,rep,name=Field2,enum=test.TheTestEnum" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameEnum) Reset() { *m = CustomNameEnum{} } +func (*CustomNameEnum) ProtoMessage() {} + +type NoExtensionsMap struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + XXX_extensions []byte `protobuf:"bytes,0,opt" json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NoExtensionsMap) Reset() { *m = NoExtensionsMap{} } +func (*NoExtensionsMap) ProtoMessage() {} + +var extRange_NoExtensionsMap = []proto.ExtensionRange{ + {100, 199}, +} + +func (*NoExtensionsMap) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_NoExtensionsMap +} +func (m *NoExtensionsMap) GetExtensions() *[]byte { + if m.XXX_extensions == nil { + m.XXX_extensions = make([]byte, 0) + } + return &m.XXX_extensions +} + +type Unrecognized struct { + Field1 *string `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *Unrecognized) Reset() { *m = Unrecognized{} } +func (*Unrecognized) ProtoMessage() {} + +type UnrecognizedWithInner struct { + Embedded []*UnrecognizedWithInner_Inner `protobuf:"bytes,1,rep,name=embedded" json:"embedded,omitempty"` + Field2 *string `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnrecognizedWithInner) Reset() { *m = UnrecognizedWithInner{} } +func (*UnrecognizedWithInner) ProtoMessage() {} + +type UnrecognizedWithInner_Inner struct { + Field1 *uint32 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *UnrecognizedWithInner_Inner) Reset() { *m = UnrecognizedWithInner_Inner{} } +func (*UnrecognizedWithInner_Inner) ProtoMessage() {} + +type UnrecognizedWithEmbed struct { + UnrecognizedWithEmbed_Embedded `protobuf:"bytes,1,opt,name=embedded,embedded=embedded" json:"embedded"` + Field2 *string `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnrecognizedWithEmbed) Reset() { *m = UnrecognizedWithEmbed{} } +func (*UnrecognizedWithEmbed) ProtoMessage() {} + +type UnrecognizedWithEmbed_Embedded struct { + Field1 *uint32 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *UnrecognizedWithEmbed_Embedded) Reset() { *m = UnrecognizedWithEmbed_Embedded{} } +func (*UnrecognizedWithEmbed_Embedded) ProtoMessage() {} + +var E_FieldA = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*float64)(nil), + Field: 100, + Name: "test.FieldA", + Tag: "fixed64,100,opt,name=FieldA", +} + +var E_FieldB = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*NinOptNative)(nil), + Field: 101, + Name: "test.FieldB", + Tag: "bytes,101,opt,name=FieldB", +} + +var E_FieldC = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*NinEmbeddedStruct)(nil), + Field: 102, + Name: "test.FieldC", + Tag: "bytes,102,opt,name=FieldC", +} + +var E_FieldA1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*float64)(nil), + Field: 100, + Name: "test.FieldA1", + Tag: "fixed64,100,opt,name=FieldA1", +} + +var E_FieldB1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*NinOptNative)(nil), + Field: 101, + Name: "test.FieldB1", + Tag: "bytes,101,opt,name=FieldB1", +} + +var E_FieldC1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*NinEmbeddedStruct)(nil), + Field: 102, + Name: "test.FieldC1", + Tag: "bytes,102,opt,name=FieldC1", +} + +func init() { + proto.RegisterEnum("test.TheTestEnum", TheTestEnum_name, TheTestEnum_value) + proto.RegisterEnum("test.AnotherTestEnum", AnotherTestEnum_name, AnotherTestEnum_value) + proto.RegisterEnum("test.NestedDefinition_NestedEnum", NestedDefinition_NestedEnum_name, NestedDefinition_NestedEnum_value) + proto.RegisterExtension(E_FieldA) + proto.RegisterExtension(E_FieldB) + proto.RegisterExtension(E_FieldC) + proto.RegisterExtension(E_FieldA1) + proto.RegisterExtension(E_FieldB1) + proto.RegisterExtension(E_FieldC1) +} +func (this *NidOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepPackedNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepPackedNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidEmbeddedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinEmbeddedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidNestedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinNestedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomDash) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNativeUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinEmbeddedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinNestedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Tree) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *OrBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AndBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Leaf) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *DeepTree) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *ADeepBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AndDeepBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *DeepLeaf) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Nil) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptEnumDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AnotherNinOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AnotherNinOptEnumDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Timer) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *MyExtendable) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *OtherExtenable) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition_NestedMessage) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedScope) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNativeDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomContainer) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNidOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameCustomType) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinEmbeddedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NoExtensionsMap) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Unrecognized) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithInner) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithInner_Inner) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithEmbed) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithEmbed_Embedded) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func ThetestDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unsafeunmarshaler/thetest.proto"), + Package: func(v string) *string { return &v }("test"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NinRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NidOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }, {Name: func(v string) *string { return &v }("NidNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidRepStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStruct"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinRepStruct"), + }}, + }, {Name: func(v string) *string { return &v }("NidOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomDash"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x64, 0x61, 0x73, 0x68, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NidRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinOptStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinNestedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNativeUnion"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStructUnion"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStructUnion"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Tree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Or"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.OrBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Leaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("OrBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Leaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("StrValue"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepTree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.ADeepBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndDeepBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepLeaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("ADeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndDeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepLeaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Tree"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Nil")}, {Name: func(v string) *string { return &v }("NidOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NidRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + DefaultValue: func(v string) *string { return &v }("C"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + DefaultValue: func(v string) *string { return &v }("E"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Timer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Time1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Time2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Data"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("MyExtendable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("OtherExtenable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("M"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.MyExtendable"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(14), + End: func(v int32) *int32 { return &v }(17), + }, {Start: func(v int32) *int32 { return &v }(10), + End: func(v int32) *int32 { return &v }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("NestedDefinition"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("EnumField"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("NM"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedMessage"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedField1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedMsg"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedField1"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("NestedEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_NESTED"), + Number: func(v int32) *int32 { return &v }(1), + }}, + }}, + }, {Name: func(v string) *string { return &v }("NestedScope"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("true"), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("CustomContainer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("CustomStruct"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptCustom"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x5, 0x46, 0x69, 0x65, 0x6c, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameCustomType"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Ids"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Values"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("CustomNameEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + }, {Name: func(v string) *string { return &v }("NoExtensionsMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0}), 64025: proto.NewExtension([]byte{0xc8, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Unrecognized"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithInner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithInner.Inner"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Inner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithEmbed"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithEmbed.Embedded"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Embedded"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("TheTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }, {Name: func(v string) *string { return &v }("AnotherTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("D"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("E"), + Number: func(v int32) *int32 { return &v }(11), + }}, + Options: &google_protobuf.EnumOptions{XXX_extensions: map[int32]proto.Extension{62001: proto.NewExtension([]byte{0x88, 0xa3, 0x1e, 0x0})}}, + }}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("FieldA"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldB"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldC"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldA1"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldB1"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldC1"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x1})}}, + }}, + } +} +func (x TheTestEnum) String() string { + s, ok := TheTestEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x AnotherTestEnum) String() string { + s, ok := AnotherTestEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x NestedDefinition_NestedEnum) String() string { + s, ok := NestedDefinition_NestedEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *NidOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptNative) + if !ok { + return fmt.Errorf("that is not of type *NidOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptNativebut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if this.Field2 != that1.Field2 { + return false + } + if this.Field3 != that1.Field3 { + return false + } + if this.Field4 != that1.Field4 { + return false + } + if this.Field5 != that1.Field5 { + return false + } + if this.Field6 != that1.Field6 { + return false + } + if this.Field7 != that1.Field7 { + return false + } + if this.Field8 != that1.Field8 { + return false + } + if this.Field9 != that1.Field9 { + return false + } + if this.Field10 != that1.Field10 { + return false + } + if this.Field11 != that1.Field11 { + return false + } + if this.Field12 != that1.Field12 { + return false + } + if this.Field13 != that1.Field13 { + return false + } + if this.Field14 != that1.Field14 { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNative) + if !ok { + return fmt.Errorf("that is not of type *NinOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativebut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", *this.Field8, *that1.Field8) + } + } else if this.Field8 != nil { + return fmt.Errorf("this.Field8 == nil && that.Field8 != nil") + } else if that1.Field8 != nil { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", *this.Field9, *that1.Field9) + } + } else if this.Field9 != nil { + return fmt.Errorf("this.Field9 == nil && that.Field9 != nil") + } else if that1.Field9 != nil { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", *this.Field10, *that1.Field10) + } + } else if this.Field10 != nil { + return fmt.Errorf("this.Field10 == nil && that.Field10 != nil") + } else if that1.Field10 != nil { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", *this.Field11, *that1.Field11) + } + } else if this.Field11 != nil { + return fmt.Errorf("this.Field11 == nil && that.Field11 != nil") + } else if that1.Field11 != nil { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", *this.Field12, *that1.Field12) + } + } else if this.Field12 != nil { + return fmt.Errorf("this.Field12 == nil && that.Field12 != nil") + } else if that1.Field12 != nil { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return false + } + } else if this.Field8 != nil { + return false + } else if that1.Field8 != nil { + return false + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return false + } + } else if this.Field9 != nil { + return false + } else if that1.Field9 != nil { + return false + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return false + } + } else if this.Field10 != nil { + return false + } else if that1.Field10 != nil { + return false + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return false + } + } else if this.Field11 != nil { + return false + } else if that1.Field11 != nil { + return false + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return false + } + } else if this.Field12 != nil { + return false + } else if that1.Field12 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepNative) + if !ok { + return fmt.Errorf("that is not of type *NidRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepNative) + if !ok { + return fmt.Errorf("that is not of type *NinRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepPackedNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepPackedNative) + if !ok { + return fmt.Errorf("that is not of type *NidRepPackedNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepPackedNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepPackedNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepPackedNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepPackedNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepPackedNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepPackedNative) + if !ok { + return fmt.Errorf("that is not of type *NinRepPackedNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepPackedNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepPackedNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepPackedNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepPackedNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptStruct) + if !ok { + return fmt.Errorf("that is not of type *NidOptStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptStructbut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(&that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(&that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if !this.Field8.Equal(&that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if this.Field2 != that1.Field2 { + return false + } + if !this.Field3.Equal(&that1.Field3) { + return false + } + if !this.Field4.Equal(&that1.Field4) { + return false + } + if this.Field6 != that1.Field6 { + return false + } + if this.Field7 != that1.Field7 { + return false + } + if !this.Field8.Equal(&that1.Field8) { + return false + } + if this.Field13 != that1.Field13 { + return false + } + if this.Field14 != that1.Field14 { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptStruct) + if !ok { + return fmt.Errorf("that is not of type *NinOptStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptStructbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if !this.Field8.Equal(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !this.Field4.Equal(that1.Field4) { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if !this.Field8.Equal(that1.Field8) { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepStruct) + if !ok { + return fmt.Errorf("that is not of type *NidRepStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepStructbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if !this.Field3[i].Equal(&that1.Field3[i]) { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if !this.Field4[i].Equal(&that1.Field4[i]) { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if !this.Field8[i].Equal(&that1.Field8[i]) { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if !this.Field3[i].Equal(&that1.Field3[i]) { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if !this.Field4[i].Equal(&that1.Field4[i]) { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if !this.Field8[i].Equal(&that1.Field8[i]) { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepStruct) + if !ok { + return fmt.Errorf("that is not of type *NinRepStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepStructbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if !this.Field3[i].Equal(that1.Field3[i]) { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if !this.Field4[i].Equal(that1.Field4[i]) { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if !this.Field8[i].Equal(that1.Field8[i]) { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if !this.Field3[i].Equal(that1.Field3[i]) { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if !this.Field4[i].Equal(that1.Field4[i]) { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if !this.Field8[i].Equal(that1.Field8[i]) { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidEmbeddedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidEmbeddedStruct) + if !ok { + return fmt.Errorf("that is not of type *NidEmbeddedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidEmbeddedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidEmbeddedStructbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(&that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidEmbeddedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidEmbeddedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(&that1.Field200) { + return false + } + if this.Field210 != that1.Field210 { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinEmbeddedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinEmbeddedStruct) + if !ok { + return fmt.Errorf("that is not of type *NinEmbeddedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinEmbeddedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinEmbeddedStructbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", *this.Field210, *that1.Field210) + } + } else if this.Field210 != nil { + return fmt.Errorf("this.Field210 == nil && that.Field210 != nil") + } else if that1.Field210 != nil { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinEmbeddedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinEmbeddedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(that1.Field200) { + return false + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return false + } + } else if this.Field210 != nil { + return false + } else if that1.Field210 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidNestedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidNestedStruct) + if !ok { + return fmt.Errorf("that is not of type *NidNestedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidNestedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidNestedStructbut is not nil && this == nil") + } + if !this.Field1.Equal(&that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if !this.Field2[i].Equal(&that1.Field2[i]) { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidNestedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidNestedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(&that1.Field1) { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if !this.Field2[i].Equal(&that1.Field2[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinNestedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinNestedStruct) + if !ok { + return fmt.Errorf("that is not of type *NinNestedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinNestedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinNestedStructbut is not nil && this == nil") + } + if !this.Field1.Equal(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if !this.Field2[i].Equal(that1.Field2[i]) { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinNestedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinNestedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(that1.Field1) { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if !this.Field2[i].Equal(that1.Field2[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptCustom) + if !ok { + return fmt.Errorf("that is not of type *NidOptCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptCustombut is not nil && this == nil") + } + if !this.Id.Equal(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id) + } + if !this.Value.Equal(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Id.Equal(that1.Id) { + return false + } + if !this.Value.Equal(that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomDash) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomDash) + if !ok { + return fmt.Errorf("that is not of type *CustomDash") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomDash but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomDashbut is not nil && this == nil") + } + if that1.Value == nil { + if this.Value != nil { + return fmt.Errorf("this.Value != nil && that1.Value == nil") + } + } else if !this.Value.Equal(*that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomDash) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomDash) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Value == nil { + if this.Value != nil { + return false + } + } else if !this.Value.Equal(*that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptCustom) + if !ok { + return fmt.Errorf("that is not of type *NinOptCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptCustombut is not nil && this == nil") + } + if that1.Id == nil { + if this.Id != nil { + return fmt.Errorf("this.Id != nil && that1.Id == nil") + } + } else if !this.Id.Equal(*that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id) + } + if that1.Value == nil { + if this.Value != nil { + return fmt.Errorf("this.Value != nil && that1.Value == nil") + } + } else if !this.Value.Equal(*that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Id == nil { + if this.Id != nil { + return false + } + } else if !this.Id.Equal(*that1.Id) { + return false + } + if that1.Value == nil { + if this.Value != nil { + return false + } + } else if !this.Value.Equal(*that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepCustom) + if !ok { + return fmt.Errorf("that is not of type *NidRepCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepCustombut is not nil && this == nil") + } + if len(this.Id) != len(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", len(this.Id), len(that1.Id)) + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return fmt.Errorf("Id this[%v](%v) Not Equal that[%v](%v)", i, this.Id[i], i, that1.Id[i]) + } + } + if len(this.Value) != len(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", len(this.Value), len(that1.Value)) + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return fmt.Errorf("Value this[%v](%v) Not Equal that[%v](%v)", i, this.Value[i], i, that1.Value[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Id) != len(that1.Id) { + return false + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return false + } + } + if len(this.Value) != len(that1.Value) { + return false + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepCustom) + if !ok { + return fmt.Errorf("that is not of type *NinRepCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepCustombut is not nil && this == nil") + } + if len(this.Id) != len(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", len(this.Id), len(that1.Id)) + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return fmt.Errorf("Id this[%v](%v) Not Equal that[%v](%v)", i, this.Id[i], i, that1.Id[i]) + } + } + if len(this.Value) != len(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", len(this.Value), len(that1.Value)) + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return fmt.Errorf("Value this[%v](%v) Not Equal that[%v](%v)", i, this.Value[i], i, that1.Value[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Id) != len(that1.Id) { + return false + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return false + } + } + if len(this.Value) != len(that1.Value) { + return false + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNativeUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNativeUnion) + if !ok { + return fmt.Errorf("that is not of type *NinOptNativeUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNativeUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativeUnionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNativeUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNativeUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinOptStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptStructUnionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !this.Field4.Equal(that1.Field4) { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinEmbeddedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinEmbeddedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinEmbeddedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinEmbeddedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinEmbeddedStructUnionbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", *this.Field210, *that1.Field210) + } + } else if this.Field210 != nil { + return fmt.Errorf("this.Field210 == nil && that.Field210 != nil") + } else if that1.Field210 != nil { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinEmbeddedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinEmbeddedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(that1.Field200) { + return false + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return false + } + } else if this.Field210 != nil { + return false + } else if that1.Field210 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinNestedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinNestedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinNestedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinNestedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinNestedStructUnionbut is not nil && this == nil") + } + if !this.Field1.Equal(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !this.Field2.Equal(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinNestedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinNestedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(that1.Field1) { + return false + } + if !this.Field2.Equal(that1.Field2) { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Tree) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Tree) + if !ok { + return fmt.Errorf("that is not of type *Tree") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Tree but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Treebut is not nil && this == nil") + } + if !this.Or.Equal(that1.Or) { + return fmt.Errorf("Or this(%v) Not Equal that(%v)", this.Or, that1.Or) + } + if !this.And.Equal(that1.And) { + return fmt.Errorf("And this(%v) Not Equal that(%v)", this.And, that1.And) + } + if !this.Leaf.Equal(that1.Leaf) { + return fmt.Errorf("Leaf this(%v) Not Equal that(%v)", this.Leaf, that1.Leaf) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Tree) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Tree) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Or.Equal(that1.Or) { + return false + } + if !this.And.Equal(that1.And) { + return false + } + if !this.Leaf.Equal(that1.Leaf) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OrBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OrBranch) + if !ok { + return fmt.Errorf("that is not of type *OrBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OrBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OrBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OrBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OrBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AndBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AndBranch) + if !ok { + return fmt.Errorf("that is not of type *AndBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AndBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AndBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AndBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AndBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Leaf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Leaf) + if !ok { + return fmt.Errorf("that is not of type *Leaf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Leaf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Leafbut is not nil && this == nil") + } + if this.Value != that1.Value { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if this.StrValue != that1.StrValue { + return fmt.Errorf("StrValue this(%v) Not Equal that(%v)", this.StrValue, that1.StrValue) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Leaf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Leaf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Value != that1.Value { + return false + } + if this.StrValue != that1.StrValue { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *DeepTree) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*DeepTree) + if !ok { + return fmt.Errorf("that is not of type *DeepTree") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *DeepTree but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *DeepTreebut is not nil && this == nil") + } + if !this.Down.Equal(that1.Down) { + return fmt.Errorf("Down this(%v) Not Equal that(%v)", this.Down, that1.Down) + } + if !this.And.Equal(that1.And) { + return fmt.Errorf("And this(%v) Not Equal that(%v)", this.And, that1.And) + } + if !this.Leaf.Equal(that1.Leaf) { + return fmt.Errorf("Leaf this(%v) Not Equal that(%v)", this.Leaf, that1.Leaf) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *DeepTree) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*DeepTree) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Down.Equal(that1.Down) { + return false + } + if !this.And.Equal(that1.And) { + return false + } + if !this.Leaf.Equal(that1.Leaf) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *ADeepBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*ADeepBranch) + if !ok { + return fmt.Errorf("that is not of type *ADeepBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *ADeepBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *ADeepBranchbut is not nil && this == nil") + } + if !this.Down.Equal(&that1.Down) { + return fmt.Errorf("Down this(%v) Not Equal that(%v)", this.Down, that1.Down) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *ADeepBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*ADeepBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Down.Equal(&that1.Down) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AndDeepBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AndDeepBranch) + if !ok { + return fmt.Errorf("that is not of type *AndDeepBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AndDeepBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AndDeepBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AndDeepBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AndDeepBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *DeepLeaf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*DeepLeaf) + if !ok { + return fmt.Errorf("that is not of type *DeepLeaf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *DeepLeaf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *DeepLeafbut is not nil && this == nil") + } + if !this.Tree.Equal(&that1.Tree) { + return fmt.Errorf("Tree this(%v) Not Equal that(%v)", this.Tree, that1.Tree) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *DeepLeaf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*DeepLeaf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Tree.Equal(&that1.Tree) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Nil) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Nil) + if !ok { + return fmt.Errorf("that is not of type *Nil") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Nil but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Nilbut is not nil && this == nil") + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Nil) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Nil) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptEnum) + if !ok { + return fmt.Errorf("that is not of type *NidOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptEnumbut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptEnum) + if !ok { + return fmt.Errorf("that is not of type *NinOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptEnumbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepEnum) + if !ok { + return fmt.Errorf("that is not of type *NidRepEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepEnumbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepEnum) + if !ok { + return fmt.Errorf("that is not of type *NinRepEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepEnumbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptEnumDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptEnumDefault) + if !ok { + return fmt.Errorf("that is not of type *NinOptEnumDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptEnumDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptEnumDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptEnumDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptEnumDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AnotherNinOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AnotherNinOptEnum) + if !ok { + return fmt.Errorf("that is not of type *AnotherNinOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AnotherNinOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AnotherNinOptEnumbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AnotherNinOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AnotherNinOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AnotherNinOptEnumDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AnotherNinOptEnumDefault) + if !ok { + return fmt.Errorf("that is not of type *AnotherNinOptEnumDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AnotherNinOptEnumDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AnotherNinOptEnumDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AnotherNinOptEnumDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AnotherNinOptEnumDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Timer) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Timer) + if !ok { + return fmt.Errorf("that is not of type *Timer") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Timer but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Timerbut is not nil && this == nil") + } + if this.Time1 != that1.Time1 { + return fmt.Errorf("Time1 this(%v) Not Equal that(%v)", this.Time1, that1.Time1) + } + if this.Time2 != that1.Time2 { + return fmt.Errorf("Time2 this(%v) Not Equal that(%v)", this.Time2, that1.Time2) + } + if !bytes.Equal(this.Data, that1.Data) { + return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Timer) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Timer) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Time1 != that1.Time1 { + return false + } + if this.Time2 != that1.Time2 { + return false + } + if !bytes.Equal(this.Data, that1.Data) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *MyExtendable) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*MyExtendable) + if !ok { + return fmt.Errorf("that is not of type *MyExtendable") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *MyExtendable but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *MyExtendablebut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return fmt.Errorf("XXX_extensions this[%v](%v) Not Equal that[%v](%v)", k, this.XXX_extensions[k], k, that1.XXX_extensions[k]) + } + } else { + return fmt.Errorf("XXX_extensions[%v] Not In that", k) + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return fmt.Errorf("XXX_extensions[%v] Not In this", k) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *MyExtendable) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*MyExtendable) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return false + } + } else { + return false + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OtherExtenable) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OtherExtenable) + if !ok { + return fmt.Errorf("that is not of type *OtherExtenable") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OtherExtenable but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OtherExtenablebut is not nil && this == nil") + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if !this.M.Equal(that1.M) { + return fmt.Errorf("M this(%v) Not Equal that(%v)", this.M, that1.M) + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return fmt.Errorf("XXX_extensions this[%v](%v) Not Equal that[%v](%v)", k, this.XXX_extensions[k], k, that1.XXX_extensions[k]) + } + } else { + return fmt.Errorf("XXX_extensions[%v] Not In that", k) + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return fmt.Errorf("XXX_extensions[%v] Not In this", k) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OtherExtenable) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OtherExtenable) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if !this.M.Equal(that1.M) { + return false + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return false + } + } else { + return false + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinitionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.EnumField != nil && that1.EnumField != nil { + if *this.EnumField != *that1.EnumField { + return fmt.Errorf("EnumField this(%v) Not Equal that(%v)", *this.EnumField, *that1.EnumField) + } + } else if this.EnumField != nil { + return fmt.Errorf("this.EnumField == nil && that.EnumField != nil") + } else if that1.EnumField != nil { + return fmt.Errorf("EnumField this(%v) Not Equal that(%v)", this.EnumField, that1.EnumField) + } + if !this.NNM.Equal(that1.NNM) { + return fmt.Errorf("NNM this(%v) Not Equal that(%v)", this.NNM, that1.NNM) + } + if !this.NM.Equal(that1.NM) { + return fmt.Errorf("NM this(%v) Not Equal that(%v)", this.NM, that1.NM) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.EnumField != nil && that1.EnumField != nil { + if *this.EnumField != *that1.EnumField { + return false + } + } else if this.EnumField != nil { + return false + } else if that1.EnumField != nil { + return false + } + if !this.NNM.Equal(that1.NNM) { + return false + } + if !this.NM.Equal(that1.NM) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition_NestedMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition_NestedMessage) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition_NestedMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition_NestedMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinition_NestedMessagebut is not nil && this == nil") + } + if this.NestedField1 != nil && that1.NestedField1 != nil { + if *this.NestedField1 != *that1.NestedField1 { + return fmt.Errorf("NestedField1 this(%v) Not Equal that(%v)", *this.NestedField1, *that1.NestedField1) + } + } else if this.NestedField1 != nil { + return fmt.Errorf("this.NestedField1 == nil && that.NestedField1 != nil") + } else if that1.NestedField1 != nil { + return fmt.Errorf("NestedField1 this(%v) Not Equal that(%v)", this.NestedField1, that1.NestedField1) + } + if !this.NNM.Equal(that1.NNM) { + return fmt.Errorf("NNM this(%v) Not Equal that(%v)", this.NNM, that1.NNM) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition_NestedMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition_NestedMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.NestedField1 != nil && that1.NestedField1 != nil { + if *this.NestedField1 != *that1.NestedField1 { + return false + } + } else if this.NestedField1 != nil { + return false + } else if that1.NestedField1 != nil { + return false + } + if !this.NNM.Equal(that1.NNM) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition_NestedMessage_NestedNestedMsg) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition_NestedMessage_NestedNestedMsg") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition_NestedMessage_NestedNestedMsg but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinition_NestedMessage_NestedNestedMsgbut is not nil && this == nil") + } + if this.NestedNestedField1 != nil && that1.NestedNestedField1 != nil { + if *this.NestedNestedField1 != *that1.NestedNestedField1 { + return fmt.Errorf("NestedNestedField1 this(%v) Not Equal that(%v)", *this.NestedNestedField1, *that1.NestedNestedField1) + } + } else if this.NestedNestedField1 != nil { + return fmt.Errorf("this.NestedNestedField1 == nil && that.NestedNestedField1 != nil") + } else if that1.NestedNestedField1 != nil { + return fmt.Errorf("NestedNestedField1 this(%v) Not Equal that(%v)", this.NestedNestedField1, that1.NestedNestedField1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition_NestedMessage_NestedNestedMsg) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.NestedNestedField1 != nil && that1.NestedNestedField1 != nil { + if *this.NestedNestedField1 != *that1.NestedNestedField1 { + return false + } + } else if this.NestedNestedField1 != nil { + return false + } else if that1.NestedNestedField1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedScope) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedScope) + if !ok { + return fmt.Errorf("that is not of type *NestedScope") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedScope but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedScopebut is not nil && this == nil") + } + if !this.A.Equal(that1.A) { + return fmt.Errorf("A this(%v) Not Equal that(%v)", this.A, that1.A) + } + if this.B != nil && that1.B != nil { + if *this.B != *that1.B { + return fmt.Errorf("B this(%v) Not Equal that(%v)", *this.B, *that1.B) + } + } else if this.B != nil { + return fmt.Errorf("this.B == nil && that.B != nil") + } else if that1.B != nil { + return fmt.Errorf("B this(%v) Not Equal that(%v)", this.B, that1.B) + } + if !this.C.Equal(that1.C) { + return fmt.Errorf("C this(%v) Not Equal that(%v)", this.C, that1.C) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedScope) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedScope) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.A.Equal(that1.A) { + return false + } + if this.B != nil && that1.B != nil { + if *this.B != *that1.B { + return false + } + } else if this.B != nil { + return false + } else if that1.B != nil { + return false + } + if !this.C.Equal(that1.C) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNativeDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNativeDefault) + if !ok { + return fmt.Errorf("that is not of type *NinOptNativeDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNativeDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativeDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", *this.Field8, *that1.Field8) + } + } else if this.Field8 != nil { + return fmt.Errorf("this.Field8 == nil && that.Field8 != nil") + } else if that1.Field8 != nil { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", *this.Field9, *that1.Field9) + } + } else if this.Field9 != nil { + return fmt.Errorf("this.Field9 == nil && that.Field9 != nil") + } else if that1.Field9 != nil { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", *this.Field10, *that1.Field10) + } + } else if this.Field10 != nil { + return fmt.Errorf("this.Field10 == nil && that.Field10 != nil") + } else if that1.Field10 != nil { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", *this.Field11, *that1.Field11) + } + } else if this.Field11 != nil { + return fmt.Errorf("this.Field11 == nil && that.Field11 != nil") + } else if that1.Field11 != nil { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", *this.Field12, *that1.Field12) + } + } else if this.Field12 != nil { + return fmt.Errorf("this.Field12 == nil && that.Field12 != nil") + } else if that1.Field12 != nil { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNativeDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNativeDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return false + } + } else if this.Field8 != nil { + return false + } else if that1.Field8 != nil { + return false + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return false + } + } else if this.Field9 != nil { + return false + } else if that1.Field9 != nil { + return false + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return false + } + } else if this.Field10 != nil { + return false + } else if that1.Field10 != nil { + return false + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return false + } + } else if this.Field11 != nil { + return false + } else if that1.Field11 != nil { + return false + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return false + } + } else if this.Field12 != nil { + return false + } else if that1.Field12 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomContainer) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomContainer) + if !ok { + return fmt.Errorf("that is not of type *CustomContainer") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomContainer but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomContainerbut is not nil && this == nil") + } + if !this.CustomStruct.Equal(&that1.CustomStruct) { + return fmt.Errorf("CustomStruct this(%v) Not Equal that(%v)", this.CustomStruct, that1.CustomStruct) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomContainer) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomContainer) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.CustomStruct.Equal(&that1.CustomStruct) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNidOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNidOptNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNidOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNidOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNidOptNativebut is not nil && this == nil") + } + if this.FieldA != that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if this.FieldC != that1.FieldC { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if this.FieldD != that1.FieldD { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", this.FieldD, that1.FieldD) + } + if this.FieldE != that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if this.FieldG != that1.FieldG { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if this.FieldJ != that1.FieldJ { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if this.FieldK != that1.FieldK { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", this.FieldK, that1.FieldK) + } + if this.FieldL != that1.FieldL { + return fmt.Errorf("FieldL this(%v) Not Equal that(%v)", this.FieldL, that1.FieldL) + } + if this.FieldM != that1.FieldM { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", this.FieldM, that1.FieldM) + } + if this.FieldN != that1.FieldN { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", this.FieldN, that1.FieldN) + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", this.FieldO, that1.FieldO) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNidOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNidOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != that1.FieldA { + return false + } + if this.FieldB != that1.FieldB { + return false + } + if this.FieldC != that1.FieldC { + return false + } + if this.FieldD != that1.FieldD { + return false + } + if this.FieldE != that1.FieldE { + return false + } + if this.FieldF != that1.FieldF { + return false + } + if this.FieldG != that1.FieldG { + return false + } + if this.FieldH != that1.FieldH { + return false + } + if this.FieldI != that1.FieldI { + return false + } + if this.FieldJ != that1.FieldJ { + return false + } + if this.FieldK != that1.FieldK { + return false + } + if this.FieldL != that1.FieldL { + return false + } + if this.FieldM != that1.FieldM { + return false + } + if this.FieldN != that1.FieldN { + return false + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinOptNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinOptNativebut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if this.FieldC != nil && that1.FieldC != nil { + if *this.FieldC != *that1.FieldC { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", *this.FieldC, *that1.FieldC) + } + } else if this.FieldC != nil { + return fmt.Errorf("this.FieldC == nil && that.FieldC != nil") + } else if that1.FieldC != nil { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if this.FieldD != nil && that1.FieldD != nil { + if *this.FieldD != *that1.FieldD { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", *this.FieldD, *that1.FieldD) + } + } else if this.FieldD != nil { + return fmt.Errorf("this.FieldD == nil && that.FieldD != nil") + } else if that1.FieldD != nil { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", this.FieldD, that1.FieldD) + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", *this.FieldE, *that1.FieldE) + } + } else if this.FieldE != nil { + return fmt.Errorf("this.FieldE == nil && that.FieldE != nil") + } else if that1.FieldE != nil { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", *this.FieldF, *that1.FieldF) + } + } else if this.FieldF != nil { + return fmt.Errorf("this.FieldF == nil && that.FieldF != nil") + } else if that1.FieldF != nil { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if this.FieldG != nil && that1.FieldG != nil { + if *this.FieldG != *that1.FieldG { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", *this.FieldG, *that1.FieldG) + } + } else if this.FieldG != nil { + return fmt.Errorf("this.FieldG == nil && that.FieldG != nil") + } else if that1.FieldG != nil { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", *this.FieldH, *that1.FieldH) + } + } else if this.FieldH != nil { + return fmt.Errorf("this.FieldH == nil && that.FieldH != nil") + } else if that1.FieldH != nil { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", *this.FieldI, *that1.FieldI) + } + } else if this.FieldI != nil { + return fmt.Errorf("this.FieldI == nil && that.FieldI != nil") + } else if that1.FieldI != nil { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if this.FieldJ != nil && that1.FieldJ != nil { + if *this.FieldJ != *that1.FieldJ { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", *this.FieldJ, *that1.FieldJ) + } + } else if this.FieldJ != nil { + return fmt.Errorf("this.FieldJ == nil && that.FieldJ != nil") + } else if that1.FieldJ != nil { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if this.FieldK != nil && that1.FieldK != nil { + if *this.FieldK != *that1.FieldK { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", *this.FieldK, *that1.FieldK) + } + } else if this.FieldK != nil { + return fmt.Errorf("this.FieldK == nil && that.FieldK != nil") + } else if that1.FieldK != nil { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", this.FieldK, that1.FieldK) + } + if this.FielL != nil && that1.FielL != nil { + if *this.FielL != *that1.FielL { + return fmt.Errorf("FielL this(%v) Not Equal that(%v)", *this.FielL, *that1.FielL) + } + } else if this.FielL != nil { + return fmt.Errorf("this.FielL == nil && that.FielL != nil") + } else if that1.FielL != nil { + return fmt.Errorf("FielL this(%v) Not Equal that(%v)", this.FielL, that1.FielL) + } + if this.FieldM != nil && that1.FieldM != nil { + if *this.FieldM != *that1.FieldM { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", *this.FieldM, *that1.FieldM) + } + } else if this.FieldM != nil { + return fmt.Errorf("this.FieldM == nil && that.FieldM != nil") + } else if that1.FieldM != nil { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", this.FieldM, that1.FieldM) + } + if this.FieldN != nil && that1.FieldN != nil { + if *this.FieldN != *that1.FieldN { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", *this.FieldN, *that1.FieldN) + } + } else if this.FieldN != nil { + return fmt.Errorf("this.FieldN == nil && that.FieldN != nil") + } else if that1.FieldN != nil { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", this.FieldN, that1.FieldN) + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", this.FieldO, that1.FieldO) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if this.FieldC != nil && that1.FieldC != nil { + if *this.FieldC != *that1.FieldC { + return false + } + } else if this.FieldC != nil { + return false + } else if that1.FieldC != nil { + return false + } + if this.FieldD != nil && that1.FieldD != nil { + if *this.FieldD != *that1.FieldD { + return false + } + } else if this.FieldD != nil { + return false + } else if that1.FieldD != nil { + return false + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return false + } + } else if this.FieldE != nil { + return false + } else if that1.FieldE != nil { + return false + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return false + } + } else if this.FieldF != nil { + return false + } else if that1.FieldF != nil { + return false + } + if this.FieldG != nil && that1.FieldG != nil { + if *this.FieldG != *that1.FieldG { + return false + } + } else if this.FieldG != nil { + return false + } else if that1.FieldG != nil { + return false + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return false + } + } else if this.FieldH != nil { + return false + } else if that1.FieldH != nil { + return false + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return false + } + } else if this.FieldI != nil { + return false + } else if that1.FieldI != nil { + return false + } + if this.FieldJ != nil && that1.FieldJ != nil { + if *this.FieldJ != *that1.FieldJ { + return false + } + } else if this.FieldJ != nil { + return false + } else if that1.FieldJ != nil { + return false + } + if this.FieldK != nil && that1.FieldK != nil { + if *this.FieldK != *that1.FieldK { + return false + } + } else if this.FieldK != nil { + return false + } else if that1.FieldK != nil { + return false + } + if this.FielL != nil && that1.FielL != nil { + if *this.FielL != *that1.FielL { + return false + } + } else if this.FielL != nil { + return false + } else if that1.FielL != nil { + return false + } + if this.FieldM != nil && that1.FieldM != nil { + if *this.FieldM != *that1.FieldM { + return false + } + } else if this.FieldM != nil { + return false + } else if that1.FieldM != nil { + return false + } + if this.FieldN != nil && that1.FieldN != nil { + if *this.FieldN != *that1.FieldN { + return false + } + } else if this.FieldN != nil { + return false + } else if that1.FieldN != nil { + return false + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinRepNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinRepNativebut is not nil && this == nil") + } + if len(this.FieldA) != len(that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", len(this.FieldA), len(that1.FieldA)) + } + for i := range this.FieldA { + if this.FieldA[i] != that1.FieldA[i] { + return fmt.Errorf("FieldA this[%v](%v) Not Equal that[%v](%v)", i, this.FieldA[i], i, that1.FieldA[i]) + } + } + if len(this.FieldB) != len(that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", len(this.FieldB), len(that1.FieldB)) + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return fmt.Errorf("FieldB this[%v](%v) Not Equal that[%v](%v)", i, this.FieldB[i], i, that1.FieldB[i]) + } + } + if len(this.FieldC) != len(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", len(this.FieldC), len(that1.FieldC)) + } + for i := range this.FieldC { + if this.FieldC[i] != that1.FieldC[i] { + return fmt.Errorf("FieldC this[%v](%v) Not Equal that[%v](%v)", i, this.FieldC[i], i, that1.FieldC[i]) + } + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if this.FieldD[i] != that1.FieldD[i] { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if len(this.FieldE) != len(that1.FieldE) { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", len(this.FieldE), len(that1.FieldE)) + } + for i := range this.FieldE { + if this.FieldE[i] != that1.FieldE[i] { + return fmt.Errorf("FieldE this[%v](%v) Not Equal that[%v](%v)", i, this.FieldE[i], i, that1.FieldE[i]) + } + } + if len(this.FieldF) != len(that1.FieldF) { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", len(this.FieldF), len(that1.FieldF)) + } + for i := range this.FieldF { + if this.FieldF[i] != that1.FieldF[i] { + return fmt.Errorf("FieldF this[%v](%v) Not Equal that[%v](%v)", i, this.FieldF[i], i, that1.FieldF[i]) + } + } + if len(this.FieldG) != len(that1.FieldG) { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", len(this.FieldG), len(that1.FieldG)) + } + for i := range this.FieldG { + if this.FieldG[i] != that1.FieldG[i] { + return fmt.Errorf("FieldG this[%v](%v) Not Equal that[%v](%v)", i, this.FieldG[i], i, that1.FieldG[i]) + } + } + if len(this.FieldH) != len(that1.FieldH) { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", len(this.FieldH), len(that1.FieldH)) + } + for i := range this.FieldH { + if this.FieldH[i] != that1.FieldH[i] { + return fmt.Errorf("FieldH this[%v](%v) Not Equal that[%v](%v)", i, this.FieldH[i], i, that1.FieldH[i]) + } + } + if len(this.FieldI) != len(that1.FieldI) { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", len(this.FieldI), len(that1.FieldI)) + } + for i := range this.FieldI { + if this.FieldI[i] != that1.FieldI[i] { + return fmt.Errorf("FieldI this[%v](%v) Not Equal that[%v](%v)", i, this.FieldI[i], i, that1.FieldI[i]) + } + } + if len(this.FieldJ) != len(that1.FieldJ) { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", len(this.FieldJ), len(that1.FieldJ)) + } + for i := range this.FieldJ { + if this.FieldJ[i] != that1.FieldJ[i] { + return fmt.Errorf("FieldJ this[%v](%v) Not Equal that[%v](%v)", i, this.FieldJ[i], i, that1.FieldJ[i]) + } + } + if len(this.FieldK) != len(that1.FieldK) { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", len(this.FieldK), len(that1.FieldK)) + } + for i := range this.FieldK { + if this.FieldK[i] != that1.FieldK[i] { + return fmt.Errorf("FieldK this[%v](%v) Not Equal that[%v](%v)", i, this.FieldK[i], i, that1.FieldK[i]) + } + } + if len(this.FieldL) != len(that1.FieldL) { + return fmt.Errorf("FieldL this(%v) Not Equal that(%v)", len(this.FieldL), len(that1.FieldL)) + } + for i := range this.FieldL { + if this.FieldL[i] != that1.FieldL[i] { + return fmt.Errorf("FieldL this[%v](%v) Not Equal that[%v](%v)", i, this.FieldL[i], i, that1.FieldL[i]) + } + } + if len(this.FieldM) != len(that1.FieldM) { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", len(this.FieldM), len(that1.FieldM)) + } + for i := range this.FieldM { + if this.FieldM[i] != that1.FieldM[i] { + return fmt.Errorf("FieldM this[%v](%v) Not Equal that[%v](%v)", i, this.FieldM[i], i, that1.FieldM[i]) + } + } + if len(this.FieldN) != len(that1.FieldN) { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", len(this.FieldN), len(that1.FieldN)) + } + for i := range this.FieldN { + if this.FieldN[i] != that1.FieldN[i] { + return fmt.Errorf("FieldN this[%v](%v) Not Equal that[%v](%v)", i, this.FieldN[i], i, that1.FieldN[i]) + } + } + if len(this.FieldO) != len(that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", len(this.FieldO), len(that1.FieldO)) + } + for i := range this.FieldO { + if !bytes.Equal(this.FieldO[i], that1.FieldO[i]) { + return fmt.Errorf("FieldO this[%v](%v) Not Equal that[%v](%v)", i, this.FieldO[i], i, that1.FieldO[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.FieldA) != len(that1.FieldA) { + return false + } + for i := range this.FieldA { + if this.FieldA[i] != that1.FieldA[i] { + return false + } + } + if len(this.FieldB) != len(that1.FieldB) { + return false + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return false + } + } + if len(this.FieldC) != len(that1.FieldC) { + return false + } + for i := range this.FieldC { + if this.FieldC[i] != that1.FieldC[i] { + return false + } + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if this.FieldD[i] != that1.FieldD[i] { + return false + } + } + if len(this.FieldE) != len(that1.FieldE) { + return false + } + for i := range this.FieldE { + if this.FieldE[i] != that1.FieldE[i] { + return false + } + } + if len(this.FieldF) != len(that1.FieldF) { + return false + } + for i := range this.FieldF { + if this.FieldF[i] != that1.FieldF[i] { + return false + } + } + if len(this.FieldG) != len(that1.FieldG) { + return false + } + for i := range this.FieldG { + if this.FieldG[i] != that1.FieldG[i] { + return false + } + } + if len(this.FieldH) != len(that1.FieldH) { + return false + } + for i := range this.FieldH { + if this.FieldH[i] != that1.FieldH[i] { + return false + } + } + if len(this.FieldI) != len(that1.FieldI) { + return false + } + for i := range this.FieldI { + if this.FieldI[i] != that1.FieldI[i] { + return false + } + } + if len(this.FieldJ) != len(that1.FieldJ) { + return false + } + for i := range this.FieldJ { + if this.FieldJ[i] != that1.FieldJ[i] { + return false + } + } + if len(this.FieldK) != len(that1.FieldK) { + return false + } + for i := range this.FieldK { + if this.FieldK[i] != that1.FieldK[i] { + return false + } + } + if len(this.FieldL) != len(that1.FieldL) { + return false + } + for i := range this.FieldL { + if this.FieldL[i] != that1.FieldL[i] { + return false + } + } + if len(this.FieldM) != len(that1.FieldM) { + return false + } + for i := range this.FieldM { + if this.FieldM[i] != that1.FieldM[i] { + return false + } + } + if len(this.FieldN) != len(that1.FieldN) { + return false + } + for i := range this.FieldN { + if this.FieldN[i] != that1.FieldN[i] { + return false + } + } + if len(this.FieldO) != len(that1.FieldO) { + return false + } + for i := range this.FieldO { + if !bytes.Equal(this.FieldO[i], that1.FieldO[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinStruct) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinStructbut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if !this.FieldC.Equal(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", *this.FieldE, *that1.FieldE) + } + } else if this.FieldE != nil { + return fmt.Errorf("this.FieldE == nil && that.FieldE != nil") + } else if that1.FieldE != nil { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", *this.FieldF, *that1.FieldF) + } + } else if this.FieldF != nil { + return fmt.Errorf("this.FieldF == nil && that.FieldF != nil") + } else if that1.FieldF != nil { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if !this.FieldG.Equal(that1.FieldG) { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", *this.FieldH, *that1.FieldH) + } + } else if this.FieldH != nil { + return fmt.Errorf("this.FieldH == nil && that.FieldH != nil") + } else if that1.FieldH != nil { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", *this.FieldI, *that1.FieldI) + } + } else if this.FieldI != nil { + return fmt.Errorf("this.FieldI == nil && that.FieldI != nil") + } else if that1.FieldI != nil { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if !bytes.Equal(this.FieldJ, that1.FieldJ) { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if !this.FieldC.Equal(that1.FieldC) { + return false + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return false + } + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return false + } + } else if this.FieldE != nil { + return false + } else if that1.FieldE != nil { + return false + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return false + } + } else if this.FieldF != nil { + return false + } else if that1.FieldF != nil { + return false + } + if !this.FieldG.Equal(that1.FieldG) { + return false + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return false + } + } else if this.FieldH != nil { + return false + } else if that1.FieldH != nil { + return false + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return false + } + } else if this.FieldI != nil { + return false + } else if that1.FieldI != nil { + return false + } + if !bytes.Equal(this.FieldJ, that1.FieldJ) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameCustomType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameCustomType) + if !ok { + return fmt.Errorf("that is not of type *CustomNameCustomType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameCustomType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameCustomTypebut is not nil && this == nil") + } + if that1.FieldA == nil { + if this.FieldA != nil { + return fmt.Errorf("this.FieldA != nil && that1.FieldA == nil") + } + } else if !this.FieldA.Equal(*that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if that1.FieldB == nil { + if this.FieldB != nil { + return fmt.Errorf("this.FieldB != nil && that1.FieldB == nil") + } + } else if !this.FieldB.Equal(*that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if len(this.FieldC) != len(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", len(this.FieldC), len(that1.FieldC)) + } + for i := range this.FieldC { + if !this.FieldC[i].Equal(that1.FieldC[i]) { + return fmt.Errorf("FieldC this[%v](%v) Not Equal that[%v](%v)", i, this.FieldC[i], i, that1.FieldC[i]) + } + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameCustomType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameCustomType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.FieldA == nil { + if this.FieldA != nil { + return false + } + } else if !this.FieldA.Equal(*that1.FieldA) { + return false + } + if that1.FieldB == nil { + if this.FieldB != nil { + return false + } + } else if !this.FieldB.Equal(*that1.FieldB) { + return false + } + if len(this.FieldC) != len(that1.FieldC) { + return false + } + for i := range this.FieldC { + if !this.FieldC[i].Equal(that1.FieldC[i]) { + return false + } + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinEmbeddedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinEmbeddedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinEmbeddedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinEmbeddedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinEmbeddedStructUnionbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.FieldA.Equal(that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinEmbeddedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinEmbeddedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.FieldA.Equal(that1.FieldA) { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameEnum) + if !ok { + return fmt.Errorf("that is not of type *CustomNameEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameEnumbut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if len(this.FieldB) != len(that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", len(this.FieldB), len(that1.FieldB)) + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return fmt.Errorf("FieldB this[%v](%v) Not Equal that[%v](%v)", i, this.FieldB[i], i, that1.FieldB[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if len(this.FieldB) != len(that1.FieldB) { + return false + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NoExtensionsMap) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NoExtensionsMap) + if !ok { + return fmt.Errorf("that is not of type *NoExtensionsMap") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NoExtensionsMap but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NoExtensionsMapbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) { + return fmt.Errorf("XXX_extensions this(%v) Not Equal that(%v)", this.XXX_extensions, that1.XXX_extensions) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NoExtensionsMap) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NoExtensionsMap) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Unrecognized) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Unrecognized) + if !ok { + return fmt.Errorf("that is not of type *Unrecognized") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Unrecognized but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Unrecognizedbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *Unrecognized) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Unrecognized) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} +func (this *UnrecognizedWithInner) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithInner) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithInner") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithInner but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithInnerbut is not nil && this == nil") + } + if len(this.Embedded) != len(that1.Embedded) { + return fmt.Errorf("Embedded this(%v) Not Equal that(%v)", len(this.Embedded), len(that1.Embedded)) + } + for i := range this.Embedded { + if !this.Embedded[i].Equal(that1.Embedded[i]) { + return fmt.Errorf("Embedded this[%v](%v) Not Equal that[%v](%v)", i, this.Embedded[i], i, that1.Embedded[i]) + } + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *UnrecognizedWithInner) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithInner) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Embedded) != len(that1.Embedded) { + return false + } + for i := range this.Embedded { + if !this.Embedded[i].Equal(that1.Embedded[i]) { + return false + } + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *UnrecognizedWithInner_Inner) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithInner_Inner) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithInner_Inner") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithInner_Inner but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithInner_Innerbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *UnrecognizedWithInner_Inner) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithInner_Inner) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} +func (this *UnrecognizedWithEmbed) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithEmbed) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithEmbed") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithEmbed but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithEmbedbut is not nil && this == nil") + } + if !this.UnrecognizedWithEmbed_Embedded.Equal(&that1.UnrecognizedWithEmbed_Embedded) { + return fmt.Errorf("UnrecognizedWithEmbed_Embedded this(%v) Not Equal that(%v)", this.UnrecognizedWithEmbed_Embedded, that1.UnrecognizedWithEmbed_Embedded) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *UnrecognizedWithEmbed) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithEmbed) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.UnrecognizedWithEmbed_Embedded.Equal(&that1.UnrecognizedWithEmbed_Embedded) { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *UnrecognizedWithEmbed_Embedded) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithEmbed_Embedded) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithEmbed_Embedded") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithEmbed_Embedded but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithEmbed_Embeddedbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *UnrecognizedWithEmbed_Embedded) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithEmbed_Embedded) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} + +type NidOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() float64 + GetField2() float32 + GetField3() int32 + GetField4() int64 + GetField5() uint32 + GetField6() uint64 + GetField7() int32 + GetField8() int64 + GetField9() uint32 + GetField10() int32 + GetField11() uint64 + GetField12() int64 + GetField13() bool + GetField14() string + GetField15() []byte +} + +func (this *NidOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptNativeFromFace(this) +} + +func (this *NidOptNative) GetField1() float64 { + return this.Field1 +} + +func (this *NidOptNative) GetField2() float32 { + return this.Field2 +} + +func (this *NidOptNative) GetField3() int32 { + return this.Field3 +} + +func (this *NidOptNative) GetField4() int64 { + return this.Field4 +} + +func (this *NidOptNative) GetField5() uint32 { + return this.Field5 +} + +func (this *NidOptNative) GetField6() uint64 { + return this.Field6 +} + +func (this *NidOptNative) GetField7() int32 { + return this.Field7 +} + +func (this *NidOptNative) GetField8() int64 { + return this.Field8 +} + +func (this *NidOptNative) GetField9() uint32 { + return this.Field9 +} + +func (this *NidOptNative) GetField10() int32 { + return this.Field10 +} + +func (this *NidOptNative) GetField11() uint64 { + return this.Field11 +} + +func (this *NidOptNative) GetField12() int64 { + return this.Field12 +} + +func (this *NidOptNative) GetField13() bool { + return this.Field13 +} + +func (this *NidOptNative) GetField14() string { + return this.Field14 +} + +func (this *NidOptNative) GetField15() []byte { + return this.Field15 +} + +func NewNidOptNativeFromFace(that NidOptNativeFace) *NidOptNative { + this := &NidOptNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *int32 + GetField4() *int64 + GetField5() *uint32 + GetField6() *uint64 + GetField7() *int32 + GetField8() *int64 + GetField9() *uint32 + GetField10() *int32 + GetField11() *uint64 + GetField12() *int64 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptNativeFromFace(this) +} + +func (this *NinOptNative) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptNative) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptNative) GetField3() *int32 { + return this.Field3 +} + +func (this *NinOptNative) GetField4() *int64 { + return this.Field4 +} + +func (this *NinOptNative) GetField5() *uint32 { + return this.Field5 +} + +func (this *NinOptNative) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptNative) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptNative) GetField8() *int64 { + return this.Field8 +} + +func (this *NinOptNative) GetField9() *uint32 { + return this.Field9 +} + +func (this *NinOptNative) GetField10() *int32 { + return this.Field10 +} + +func (this *NinOptNative) GetField11() *uint64 { + return this.Field11 +} + +func (this *NinOptNative) GetField12() *int64 { + return this.Field12 +} + +func (this *NinOptNative) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptNative) GetField14() *string { + return this.Field14 +} + +func (this *NinOptNative) GetField15() []byte { + return this.Field15 +} + +func NewNinOptNativeFromFace(that NinOptNativeFace) *NinOptNative { + this := &NinOptNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NidRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepNativeFromFace(this) +} + +func (this *NidRepNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NidRepNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NidRepNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NidRepNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NidRepNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NidRepNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NidRepNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NidRepNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NidRepNative) GetField13() []bool { + return this.Field13 +} + +func (this *NidRepNative) GetField14() []string { + return this.Field14 +} + +func (this *NidRepNative) GetField15() [][]byte { + return this.Field15 +} + +func NewNidRepNativeFromFace(that NidRepNativeFace) *NidRepNative { + this := &NidRepNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NinRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepNativeFromFace(this) +} + +func (this *NinRepNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NinRepNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NinRepNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NinRepNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NinRepNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NinRepNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NinRepNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NinRepNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NinRepNative) GetField13() []bool { + return this.Field13 +} + +func (this *NinRepNative) GetField14() []string { + return this.Field14 +} + +func (this *NinRepNative) GetField15() [][]byte { + return this.Field15 +} + +func NewNinRepNativeFromFace(that NinRepNativeFace) *NinRepNative { + this := &NinRepNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepPackedNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool +} + +func (this *NidRepPackedNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepPackedNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepPackedNativeFromFace(this) +} + +func (this *NidRepPackedNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepPackedNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepPackedNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NidRepPackedNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NidRepPackedNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NidRepPackedNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepPackedNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepPackedNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NidRepPackedNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NidRepPackedNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NidRepPackedNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NidRepPackedNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NidRepPackedNative) GetField13() []bool { + return this.Field13 +} + +func NewNidRepPackedNativeFromFace(that NidRepPackedNativeFace) *NidRepPackedNative { + this := &NidRepPackedNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + return this +} + +type NinRepPackedNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool +} + +func (this *NinRepPackedNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepPackedNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepPackedNativeFromFace(this) +} + +func (this *NinRepPackedNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepPackedNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepPackedNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NinRepPackedNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NinRepPackedNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NinRepPackedNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepPackedNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepPackedNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NinRepPackedNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NinRepPackedNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NinRepPackedNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NinRepPackedNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NinRepPackedNative) GetField13() []bool { + return this.Field13 +} + +func NewNinRepPackedNativeFromFace(that NinRepPackedNativeFace) *NinRepPackedNative { + this := &NinRepPackedNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + return this +} + +type NidOptStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() float64 + GetField2() float32 + GetField3() NidOptNative + GetField4() NinOptNative + GetField6() uint64 + GetField7() int32 + GetField8() NidOptNative + GetField13() bool + GetField14() string + GetField15() []byte +} + +func (this *NidOptStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptStructFromFace(this) +} + +func (this *NidOptStruct) GetField1() float64 { + return this.Field1 +} + +func (this *NidOptStruct) GetField2() float32 { + return this.Field2 +} + +func (this *NidOptStruct) GetField3() NidOptNative { + return this.Field3 +} + +func (this *NidOptStruct) GetField4() NinOptNative { + return this.Field4 +} + +func (this *NidOptStruct) GetField6() uint64 { + return this.Field6 +} + +func (this *NidOptStruct) GetField7() int32 { + return this.Field7 +} + +func (this *NidOptStruct) GetField8() NidOptNative { + return this.Field8 +} + +func (this *NidOptStruct) GetField13() bool { + return this.Field13 +} + +func (this *NidOptStruct) GetField14() string { + return this.Field14 +} + +func (this *NidOptStruct) GetField15() []byte { + return this.Field15 +} + +func NewNidOptStructFromFace(that NidOptStructFace) *NidOptStruct { + this := &NidOptStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *NidOptNative + GetField4() *NinOptNative + GetField6() *uint64 + GetField7() *int32 + GetField8() *NidOptNative + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptStructFromFace(this) +} + +func (this *NinOptStruct) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptStruct) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptStruct) GetField3() *NidOptNative { + return this.Field3 +} + +func (this *NinOptStruct) GetField4() *NinOptNative { + return this.Field4 +} + +func (this *NinOptStruct) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptStruct) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptStruct) GetField8() *NidOptNative { + return this.Field8 +} + +func (this *NinOptStruct) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptStruct) GetField14() *string { + return this.Field14 +} + +func (this *NinOptStruct) GetField15() []byte { + return this.Field15 +} + +func NewNinOptStructFromFace(that NinOptStructFace) *NinOptStruct { + this := &NinOptStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []NidOptNative + GetField4() []NinOptNative + GetField6() []uint64 + GetField7() []int32 + GetField8() []NidOptNative + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NidRepStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepStructFromFace(this) +} + +func (this *NidRepStruct) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepStruct) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepStruct) GetField3() []NidOptNative { + return this.Field3 +} + +func (this *NidRepStruct) GetField4() []NinOptNative { + return this.Field4 +} + +func (this *NidRepStruct) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepStruct) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepStruct) GetField8() []NidOptNative { + return this.Field8 +} + +func (this *NidRepStruct) GetField13() []bool { + return this.Field13 +} + +func (this *NidRepStruct) GetField14() []string { + return this.Field14 +} + +func (this *NidRepStruct) GetField15() [][]byte { + return this.Field15 +} + +func NewNidRepStructFromFace(that NidRepStructFace) *NidRepStruct { + this := &NidRepStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinRepStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []*NidOptNative + GetField4() []*NinOptNative + GetField6() []uint64 + GetField7() []int32 + GetField8() []*NidOptNative + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NinRepStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepStructFromFace(this) +} + +func (this *NinRepStruct) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepStruct) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepStruct) GetField3() []*NidOptNative { + return this.Field3 +} + +func (this *NinRepStruct) GetField4() []*NinOptNative { + return this.Field4 +} + +func (this *NinRepStruct) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepStruct) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepStruct) GetField8() []*NidOptNative { + return this.Field8 +} + +func (this *NinRepStruct) GetField13() []bool { + return this.Field13 +} + +func (this *NinRepStruct) GetField14() []string { + return this.Field14 +} + +func (this *NinRepStruct) GetField15() [][]byte { + return this.Field15 +} + +func NewNinRepStructFromFace(that NinRepStructFace) *NinRepStruct { + this := &NinRepStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidEmbeddedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() NidOptNative + GetField210() bool +} + +func (this *NidEmbeddedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidEmbeddedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidEmbeddedStructFromFace(this) +} + +func (this *NidEmbeddedStruct) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NidEmbeddedStruct) GetField200() NidOptNative { + return this.Field200 +} + +func (this *NidEmbeddedStruct) GetField210() bool { + return this.Field210 +} + +func NewNidEmbeddedStructFromFace(that NidEmbeddedStructFace) *NidEmbeddedStruct { + this := &NidEmbeddedStruct{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NinEmbeddedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() *NidOptNative + GetField210() *bool +} + +func (this *NinEmbeddedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinEmbeddedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinEmbeddedStructFromFace(this) +} + +func (this *NinEmbeddedStruct) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NinEmbeddedStruct) GetField200() *NidOptNative { + return this.Field200 +} + +func (this *NinEmbeddedStruct) GetField210() *bool { + return this.Field210 +} + +func NewNinEmbeddedStructFromFace(that NinEmbeddedStructFace) *NinEmbeddedStruct { + this := &NinEmbeddedStruct{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NidNestedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() NidOptStruct + GetField2() []NidRepStruct +} + +func (this *NidNestedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidNestedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidNestedStructFromFace(this) +} + +func (this *NidNestedStruct) GetField1() NidOptStruct { + return this.Field1 +} + +func (this *NidNestedStruct) GetField2() []NidRepStruct { + return this.Field2 +} + +func NewNidNestedStructFromFace(that NidNestedStructFace) *NidNestedStruct { + this := &NidNestedStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + return this +} + +type NinNestedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *NinOptStruct + GetField2() []*NinRepStruct +} + +func (this *NinNestedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinNestedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinNestedStructFromFace(this) +} + +func (this *NinNestedStruct) GetField1() *NinOptStruct { + return this.Field1 +} + +func (this *NinNestedStruct) GetField2() []*NinRepStruct { + return this.Field2 +} + +func NewNinNestedStructFromFace(that NinNestedStructFace) *NinNestedStruct { + this := &NinNestedStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + return this +} + +type NidOptCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() Uuid + GetValue() github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NidOptCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptCustomFromFace(this) +} + +func (this *NidOptCustom) GetId() Uuid { + return this.Id +} + +func (this *NidOptCustom) GetValue() github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNidOptCustomFromFace(that NidOptCustomFace) *NidOptCustom { + this := &NidOptCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type CustomDashFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetValue() *github_com_gogo_protobuf_test_custom_dash_type.Bytes +} + +func (this *CustomDash) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomDash) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomDashFromFace(this) +} + +func (this *CustomDash) GetValue() *github_com_gogo_protobuf_test_custom_dash_type.Bytes { + return this.Value +} + +func NewCustomDashFromFace(that CustomDashFace) *CustomDash { + this := &CustomDash{} + this.Value = that.GetValue() + return this +} + +type NinOptCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() *Uuid + GetValue() *github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NinOptCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptCustomFromFace(this) +} + +func (this *NinOptCustom) GetId() *Uuid { + return this.Id +} + +func (this *NinOptCustom) GetValue() *github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNinOptCustomFromFace(that NinOptCustomFace) *NinOptCustom { + this := &NinOptCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NidRepCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() []Uuid + GetValue() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NidRepCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepCustomFromFace(this) +} + +func (this *NidRepCustom) GetId() []Uuid { + return this.Id +} + +func (this *NidRepCustom) GetValue() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNidRepCustomFromFace(that NidRepCustomFace) *NidRepCustom { + this := &NidRepCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NinRepCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() []Uuid + GetValue() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NinRepCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepCustomFromFace(this) +} + +func (this *NinRepCustom) GetId() []Uuid { + return this.Id +} + +func (this *NinRepCustom) GetValue() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNinRepCustomFromFace(that NinRepCustomFace) *NinRepCustom { + this := &NinRepCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NinOptNativeUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *int32 + GetField4() *int64 + GetField5() *uint32 + GetField6() *uint64 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptNativeUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptNativeUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptNativeUnionFromFace(this) +} + +func (this *NinOptNativeUnion) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptNativeUnion) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptNativeUnion) GetField3() *int32 { + return this.Field3 +} + +func (this *NinOptNativeUnion) GetField4() *int64 { + return this.Field4 +} + +func (this *NinOptNativeUnion) GetField5() *uint32 { + return this.Field5 +} + +func (this *NinOptNativeUnion) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptNativeUnion) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptNativeUnion) GetField14() *string { + return this.Field14 +} + +func (this *NinOptNativeUnion) GetField15() []byte { + return this.Field15 +} + +func NewNinOptNativeUnionFromFace(that NinOptNativeUnionFace) *NinOptNativeUnion { + this := &NinOptNativeUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *NidOptNative + GetField4() *NinOptNative + GetField6() *uint64 + GetField7() *int32 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptStructUnionFromFace(this) +} + +func (this *NinOptStructUnion) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptStructUnion) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptStructUnion) GetField3() *NidOptNative { + return this.Field3 +} + +func (this *NinOptStructUnion) GetField4() *NinOptNative { + return this.Field4 +} + +func (this *NinOptStructUnion) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptStructUnion) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptStructUnion) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptStructUnion) GetField14() *string { + return this.Field14 +} + +func (this *NinOptStructUnion) GetField15() []byte { + return this.Field15 +} + +func NewNinOptStructUnionFromFace(that NinOptStructUnionFace) *NinOptStructUnion { + this := &NinOptStructUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinEmbeddedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() *NinOptNative + GetField210() *bool +} + +func (this *NinEmbeddedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinEmbeddedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinEmbeddedStructUnionFromFace(this) +} + +func (this *NinEmbeddedStructUnion) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NinEmbeddedStructUnion) GetField200() *NinOptNative { + return this.Field200 +} + +func (this *NinEmbeddedStructUnion) GetField210() *bool { + return this.Field210 +} + +func NewNinEmbeddedStructUnionFromFace(that NinEmbeddedStructUnionFace) *NinEmbeddedStructUnion { + this := &NinEmbeddedStructUnion{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NinNestedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *NinOptNativeUnion + GetField2() *NinOptStructUnion + GetField3() *NinEmbeddedStructUnion +} + +func (this *NinNestedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinNestedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinNestedStructUnionFromFace(this) +} + +func (this *NinNestedStructUnion) GetField1() *NinOptNativeUnion { + return this.Field1 +} + +func (this *NinNestedStructUnion) GetField2() *NinOptStructUnion { + return this.Field2 +} + +func (this *NinNestedStructUnion) GetField3() *NinEmbeddedStructUnion { + return this.Field3 +} + +func NewNinNestedStructUnionFromFace(that NinNestedStructUnionFace) *NinNestedStructUnion { + this := &NinNestedStructUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + return this +} + +type TreeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetOr() *OrBranch + GetAnd() *AndBranch + GetLeaf() *Leaf +} + +func (this *Tree) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Tree) TestProto() github_com_gogo_protobuf_proto.Message { + return NewTreeFromFace(this) +} + +func (this *Tree) GetOr() *OrBranch { + return this.Or +} + +func (this *Tree) GetAnd() *AndBranch { + return this.And +} + +func (this *Tree) GetLeaf() *Leaf { + return this.Leaf +} + +func NewTreeFromFace(that TreeFace) *Tree { + this := &Tree{} + this.Or = that.GetOr() + this.And = that.GetAnd() + this.Leaf = that.GetLeaf() + return this +} + +type OrBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() Tree + GetRight() Tree +} + +func (this *OrBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *OrBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewOrBranchFromFace(this) +} + +func (this *OrBranch) GetLeft() Tree { + return this.Left +} + +func (this *OrBranch) GetRight() Tree { + return this.Right +} + +func NewOrBranchFromFace(that OrBranchFace) *OrBranch { + this := &OrBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type AndBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() Tree + GetRight() Tree +} + +func (this *AndBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AndBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAndBranchFromFace(this) +} + +func (this *AndBranch) GetLeft() Tree { + return this.Left +} + +func (this *AndBranch) GetRight() Tree { + return this.Right +} + +func NewAndBranchFromFace(that AndBranchFace) *AndBranch { + this := &AndBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type LeafFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetValue() int64 + GetStrValue() string +} + +func (this *Leaf) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Leaf) TestProto() github_com_gogo_protobuf_proto.Message { + return NewLeafFromFace(this) +} + +func (this *Leaf) GetValue() int64 { + return this.Value +} + +func (this *Leaf) GetStrValue() string { + return this.StrValue +} + +func NewLeafFromFace(that LeafFace) *Leaf { + this := &Leaf{} + this.Value = that.GetValue() + this.StrValue = that.GetStrValue() + return this +} + +type DeepTreeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetDown() *ADeepBranch + GetAnd() *AndDeepBranch + GetLeaf() *DeepLeaf +} + +func (this *DeepTree) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *DeepTree) TestProto() github_com_gogo_protobuf_proto.Message { + return NewDeepTreeFromFace(this) +} + +func (this *DeepTree) GetDown() *ADeepBranch { + return this.Down +} + +func (this *DeepTree) GetAnd() *AndDeepBranch { + return this.And +} + +func (this *DeepTree) GetLeaf() *DeepLeaf { + return this.Leaf +} + +func NewDeepTreeFromFace(that DeepTreeFace) *DeepTree { + this := &DeepTree{} + this.Down = that.GetDown() + this.And = that.GetAnd() + this.Leaf = that.GetLeaf() + return this +} + +type ADeepBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetDown() DeepTree +} + +func (this *ADeepBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *ADeepBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewADeepBranchFromFace(this) +} + +func (this *ADeepBranch) GetDown() DeepTree { + return this.Down +} + +func NewADeepBranchFromFace(that ADeepBranchFace) *ADeepBranch { + this := &ADeepBranch{} + this.Down = that.GetDown() + return this +} + +type AndDeepBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() DeepTree + GetRight() DeepTree +} + +func (this *AndDeepBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AndDeepBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAndDeepBranchFromFace(this) +} + +func (this *AndDeepBranch) GetLeft() DeepTree { + return this.Left +} + +func (this *AndDeepBranch) GetRight() DeepTree { + return this.Right +} + +func NewAndDeepBranchFromFace(that AndDeepBranchFace) *AndDeepBranch { + this := &AndDeepBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type DeepLeafFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetTree() Tree +} + +func (this *DeepLeaf) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *DeepLeaf) TestProto() github_com_gogo_protobuf_proto.Message { + return NewDeepLeafFromFace(this) +} + +func (this *DeepLeaf) GetTree() Tree { + return this.Tree +} + +func NewDeepLeafFromFace(that DeepLeafFace) *DeepLeaf { + this := &DeepLeaf{} + this.Tree = that.GetTree() + return this +} + +type NilFace interface { + Proto() github_com_gogo_protobuf_proto.Message +} + +func (this *Nil) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Nil) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNilFromFace(this) +} + +func NewNilFromFace(that NilFace) *Nil { + this := &Nil{} + return this +} + +type NidOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() TheTestEnum +} + +func (this *NidOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptEnumFromFace(this) +} + +func (this *NidOptEnum) GetField1() TheTestEnum { + return this.Field1 +} + +func NewNidOptEnumFromFace(that NidOptEnumFace) *NidOptEnum { + this := &NidOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type NinOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *TheTestEnum +} + +func (this *NinOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptEnumFromFace(this) +} + +func (this *NinOptEnum) GetField1() *TheTestEnum { + return this.Field1 +} + +func NewNinOptEnumFromFace(that NinOptEnumFace) *NinOptEnum { + this := &NinOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type NidRepEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []TheTestEnum +} + +func (this *NidRepEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepEnumFromFace(this) +} + +func (this *NidRepEnum) GetField1() []TheTestEnum { + return this.Field1 +} + +func NewNidRepEnumFromFace(that NidRepEnumFace) *NidRepEnum { + this := &NidRepEnum{} + this.Field1 = that.GetField1() + return this +} + +type NinRepEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []TheTestEnum +} + +func (this *NinRepEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepEnumFromFace(this) +} + +func (this *NinRepEnum) GetField1() []TheTestEnum { + return this.Field1 +} + +func NewNinRepEnumFromFace(that NinRepEnumFace) *NinRepEnum { + this := &NinRepEnum{} + this.Field1 = that.GetField1() + return this +} + +type AnotherNinOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *AnotherTestEnum +} + +func (this *AnotherNinOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AnotherNinOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAnotherNinOptEnumFromFace(this) +} + +func (this *AnotherNinOptEnum) GetField1() *AnotherTestEnum { + return this.Field1 +} + +func NewAnotherNinOptEnumFromFace(that AnotherNinOptEnumFace) *AnotherNinOptEnum { + this := &AnotherNinOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type TimerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetTime1() int64 + GetTime2() int64 + GetData() []byte +} + +func (this *Timer) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Timer) TestProto() github_com_gogo_protobuf_proto.Message { + return NewTimerFromFace(this) +} + +func (this *Timer) GetTime1() int64 { + return this.Time1 +} + +func (this *Timer) GetTime2() int64 { + return this.Time2 +} + +func (this *Timer) GetData() []byte { + return this.Data +} + +func NewTimerFromFace(that TimerFace) *Timer { + this := &Timer{} + this.Time1 = that.GetTime1() + this.Time2 = that.GetTime2() + this.Data = that.GetData() + return this +} + +type NestedDefinitionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *int64 + GetEnumField() *NestedDefinition_NestedEnum + GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg + GetNM() *NestedDefinition_NestedMessage +} + +func (this *NestedDefinition) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinitionFromFace(this) +} + +func (this *NestedDefinition) GetField1() *int64 { + return this.Field1 +} + +func (this *NestedDefinition) GetEnumField() *NestedDefinition_NestedEnum { + return this.EnumField +} + +func (this *NestedDefinition) GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.NNM +} + +func (this *NestedDefinition) GetNM() *NestedDefinition_NestedMessage { + return this.NM +} + +func NewNestedDefinitionFromFace(that NestedDefinitionFace) *NestedDefinition { + this := &NestedDefinition{} + this.Field1 = that.GetField1() + this.EnumField = that.GetEnumField() + this.NNM = that.GetNNM() + this.NM = that.GetNM() + return this +} + +type NestedDefinition_NestedMessageFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNestedField1() *uint64 + GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg +} + +func (this *NestedDefinition_NestedMessage) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition_NestedMessage) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinition_NestedMessageFromFace(this) +} + +func (this *NestedDefinition_NestedMessage) GetNestedField1() *uint64 { + return this.NestedField1 +} + +func (this *NestedDefinition_NestedMessage) GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.NNM +} + +func NewNestedDefinition_NestedMessageFromFace(that NestedDefinition_NestedMessageFace) *NestedDefinition_NestedMessage { + this := &NestedDefinition_NestedMessage{} + this.NestedField1 = that.GetNestedField1() + this.NNM = that.GetNNM() + return this +} + +type NestedDefinition_NestedMessage_NestedNestedMsgFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNestedNestedField1() *string +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinition_NestedMessage_NestedNestedMsgFromFace(this) +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) GetNestedNestedField1() *string { + return this.NestedNestedField1 +} + +func NewNestedDefinition_NestedMessage_NestedNestedMsgFromFace(that NestedDefinition_NestedMessage_NestedNestedMsgFace) *NestedDefinition_NestedMessage_NestedNestedMsg { + this := &NestedDefinition_NestedMessage_NestedNestedMsg{} + this.NestedNestedField1 = that.GetNestedNestedField1() + return this +} + +type NestedScopeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetA() *NestedDefinition_NestedMessage_NestedNestedMsg + GetB() *NestedDefinition_NestedEnum + GetC() *NestedDefinition_NestedMessage +} + +func (this *NestedScope) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedScope) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedScopeFromFace(this) +} + +func (this *NestedScope) GetA() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.A +} + +func (this *NestedScope) GetB() *NestedDefinition_NestedEnum { + return this.B +} + +func (this *NestedScope) GetC() *NestedDefinition_NestedMessage { + return this.C +} + +func NewNestedScopeFromFace(that NestedScopeFace) *NestedScope { + this := &NestedScope{} + this.A = that.GetA() + this.B = that.GetB() + this.C = that.GetC() + return this +} + +type CustomContainerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetCustomStruct() NidOptCustom +} + +func (this *CustomContainer) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomContainer) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomContainerFromFace(this) +} + +func (this *CustomContainer) GetCustomStruct() NidOptCustom { + return this.CustomStruct +} + +func NewCustomContainerFromFace(that CustomContainerFace) *CustomContainer { + this := &CustomContainer{} + this.CustomStruct = that.GetCustomStruct() + return this +} + +type CustomNameNidOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() float64 + GetFieldB() float32 + GetFieldC() int32 + GetFieldD() int64 + GetFieldE() uint32 + GetFieldF() uint64 + GetFieldG() int32 + GetFieldH() int64 + GetFieldI() uint32 + GetFieldJ() int32 + GetFieldK() uint64 + GetFieldL() int64 + GetFieldM() bool + GetFieldN() string + GetFieldO() []byte +} + +func (this *CustomNameNidOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNidOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNidOptNativeFromFace(this) +} + +func (this *CustomNameNidOptNative) GetFieldA() float64 { + return this.FieldA +} + +func (this *CustomNameNidOptNative) GetFieldB() float32 { + return this.FieldB +} + +func (this *CustomNameNidOptNative) GetFieldC() int32 { + return this.FieldC +} + +func (this *CustomNameNidOptNative) GetFieldD() int64 { + return this.FieldD +} + +func (this *CustomNameNidOptNative) GetFieldE() uint32 { + return this.FieldE +} + +func (this *CustomNameNidOptNative) GetFieldF() uint64 { + return this.FieldF +} + +func (this *CustomNameNidOptNative) GetFieldG() int32 { + return this.FieldG +} + +func (this *CustomNameNidOptNative) GetFieldH() int64 { + return this.FieldH +} + +func (this *CustomNameNidOptNative) GetFieldI() uint32 { + return this.FieldI +} + +func (this *CustomNameNidOptNative) GetFieldJ() int32 { + return this.FieldJ +} + +func (this *CustomNameNidOptNative) GetFieldK() uint64 { + return this.FieldK +} + +func (this *CustomNameNidOptNative) GetFieldL() int64 { + return this.FieldL +} + +func (this *CustomNameNidOptNative) GetFieldM() bool { + return this.FieldM +} + +func (this *CustomNameNidOptNative) GetFieldN() string { + return this.FieldN +} + +func (this *CustomNameNidOptNative) GetFieldO() []byte { + return this.FieldO +} + +func NewCustomNameNidOptNativeFromFace(that CustomNameNidOptNativeFace) *CustomNameNidOptNative { + this := &CustomNameNidOptNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FieldL = that.GetFieldL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *float64 + GetFieldB() *float32 + GetFieldC() *int32 + GetFieldD() *int64 + GetFieldE() *uint32 + GetFieldF() *uint64 + GetFieldG() *int32 + GetFieldH() *int64 + GetFieldI() *uint32 + GetFieldJ() *int32 + GetFieldK() *uint64 + GetFielL() *int64 + GetFieldM() *bool + GetFieldN() *string + GetFieldO() []byte +} + +func (this *CustomNameNinOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinOptNativeFromFace(this) +} + +func (this *CustomNameNinOptNative) GetFieldA() *float64 { + return this.FieldA +} + +func (this *CustomNameNinOptNative) GetFieldB() *float32 { + return this.FieldB +} + +func (this *CustomNameNinOptNative) GetFieldC() *int32 { + return this.FieldC +} + +func (this *CustomNameNinOptNative) GetFieldD() *int64 { + return this.FieldD +} + +func (this *CustomNameNinOptNative) GetFieldE() *uint32 { + return this.FieldE +} + +func (this *CustomNameNinOptNative) GetFieldF() *uint64 { + return this.FieldF +} + +func (this *CustomNameNinOptNative) GetFieldG() *int32 { + return this.FieldG +} + +func (this *CustomNameNinOptNative) GetFieldH() *int64 { + return this.FieldH +} + +func (this *CustomNameNinOptNative) GetFieldI() *uint32 { + return this.FieldI +} + +func (this *CustomNameNinOptNative) GetFieldJ() *int32 { + return this.FieldJ +} + +func (this *CustomNameNinOptNative) GetFieldK() *uint64 { + return this.FieldK +} + +func (this *CustomNameNinOptNative) GetFielL() *int64 { + return this.FielL +} + +func (this *CustomNameNinOptNative) GetFieldM() *bool { + return this.FieldM +} + +func (this *CustomNameNinOptNative) GetFieldN() *string { + return this.FieldN +} + +func (this *CustomNameNinOptNative) GetFieldO() []byte { + return this.FieldO +} + +func NewCustomNameNinOptNativeFromFace(that CustomNameNinOptNativeFace) *CustomNameNinOptNative { + this := &CustomNameNinOptNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FielL = that.GetFielL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() []float64 + GetFieldB() []float32 + GetFieldC() []int32 + GetFieldD() []int64 + GetFieldE() []uint32 + GetFieldF() []uint64 + GetFieldG() []int32 + GetFieldH() []int64 + GetFieldI() []uint32 + GetFieldJ() []int32 + GetFieldK() []uint64 + GetFieldL() []int64 + GetFieldM() []bool + GetFieldN() []string + GetFieldO() [][]byte +} + +func (this *CustomNameNinRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinRepNativeFromFace(this) +} + +func (this *CustomNameNinRepNative) GetFieldA() []float64 { + return this.FieldA +} + +func (this *CustomNameNinRepNative) GetFieldB() []float32 { + return this.FieldB +} + +func (this *CustomNameNinRepNative) GetFieldC() []int32 { + return this.FieldC +} + +func (this *CustomNameNinRepNative) GetFieldD() []int64 { + return this.FieldD +} + +func (this *CustomNameNinRepNative) GetFieldE() []uint32 { + return this.FieldE +} + +func (this *CustomNameNinRepNative) GetFieldF() []uint64 { + return this.FieldF +} + +func (this *CustomNameNinRepNative) GetFieldG() []int32 { + return this.FieldG +} + +func (this *CustomNameNinRepNative) GetFieldH() []int64 { + return this.FieldH +} + +func (this *CustomNameNinRepNative) GetFieldI() []uint32 { + return this.FieldI +} + +func (this *CustomNameNinRepNative) GetFieldJ() []int32 { + return this.FieldJ +} + +func (this *CustomNameNinRepNative) GetFieldK() []uint64 { + return this.FieldK +} + +func (this *CustomNameNinRepNative) GetFieldL() []int64 { + return this.FieldL +} + +func (this *CustomNameNinRepNative) GetFieldM() []bool { + return this.FieldM +} + +func (this *CustomNameNinRepNative) GetFieldN() []string { + return this.FieldN +} + +func (this *CustomNameNinRepNative) GetFieldO() [][]byte { + return this.FieldO +} + +func NewCustomNameNinRepNativeFromFace(that CustomNameNinRepNativeFace) *CustomNameNinRepNative { + this := &CustomNameNinRepNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FieldL = that.GetFieldL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *float64 + GetFieldB() *float32 + GetFieldC() *NidOptNative + GetFieldD() []*NinOptNative + GetFieldE() *uint64 + GetFieldF() *int32 + GetFieldG() *NidOptNative + GetFieldH() *bool + GetFieldI() *string + GetFieldJ() []byte +} + +func (this *CustomNameNinStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinStructFromFace(this) +} + +func (this *CustomNameNinStruct) GetFieldA() *float64 { + return this.FieldA +} + +func (this *CustomNameNinStruct) GetFieldB() *float32 { + return this.FieldB +} + +func (this *CustomNameNinStruct) GetFieldC() *NidOptNative { + return this.FieldC +} + +func (this *CustomNameNinStruct) GetFieldD() []*NinOptNative { + return this.FieldD +} + +func (this *CustomNameNinStruct) GetFieldE() *uint64 { + return this.FieldE +} + +func (this *CustomNameNinStruct) GetFieldF() *int32 { + return this.FieldF +} + +func (this *CustomNameNinStruct) GetFieldG() *NidOptNative { + return this.FieldG +} + +func (this *CustomNameNinStruct) GetFieldH() *bool { + return this.FieldH +} + +func (this *CustomNameNinStruct) GetFieldI() *string { + return this.FieldI +} + +func (this *CustomNameNinStruct) GetFieldJ() []byte { + return this.FieldJ +} + +func NewCustomNameNinStructFromFace(that CustomNameNinStructFace) *CustomNameNinStruct { + this := &CustomNameNinStruct{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + return this +} + +type CustomNameCustomTypeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *Uuid + GetFieldB() *github_com_gogo_protobuf_test_custom.Uint128 + GetFieldC() []Uuid + GetFieldD() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *CustomNameCustomType) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameCustomType) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameCustomTypeFromFace(this) +} + +func (this *CustomNameCustomType) GetFieldA() *Uuid { + return this.FieldA +} + +func (this *CustomNameCustomType) GetFieldB() *github_com_gogo_protobuf_test_custom.Uint128 { + return this.FieldB +} + +func (this *CustomNameCustomType) GetFieldC() []Uuid { + return this.FieldC +} + +func (this *CustomNameCustomType) GetFieldD() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.FieldD +} + +func NewCustomNameCustomTypeFromFace(that CustomNameCustomTypeFace) *CustomNameCustomType { + this := &CustomNameCustomType{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + return this +} + +type CustomNameNinEmbeddedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetFieldA() *NinOptNative + GetFieldB() *bool +} + +func (this *CustomNameNinEmbeddedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinEmbeddedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinEmbeddedStructUnionFromFace(this) +} + +func (this *CustomNameNinEmbeddedStructUnion) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *CustomNameNinEmbeddedStructUnion) GetFieldA() *NinOptNative { + return this.FieldA +} + +func (this *CustomNameNinEmbeddedStructUnion) GetFieldB() *bool { + return this.FieldB +} + +func NewCustomNameNinEmbeddedStructUnionFromFace(that CustomNameNinEmbeddedStructUnionFace) *CustomNameNinEmbeddedStructUnion { + this := &CustomNameNinEmbeddedStructUnion{} + this.NidOptNative = that.GetNidOptNative() + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + return this +} + +type CustomNameEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *TheTestEnum + GetFieldB() []TheTestEnum +} + +func (this *CustomNameEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameEnumFromFace(this) +} + +func (this *CustomNameEnum) GetFieldA() *TheTestEnum { + return this.FieldA +} + +func (this *CustomNameEnum) GetFieldB() []TheTestEnum { + return this.FieldB +} + +func NewCustomNameEnumFromFace(that CustomNameEnumFace) *CustomNameEnum { + this := &CustomNameEnum{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + return this +} + +type UnrecognizedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *string +} + +func (this *Unrecognized) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Unrecognized) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedFromFace(this) +} + +func (this *Unrecognized) GetField1() *string { + return this.Field1 +} + +func NewUnrecognizedFromFace(that UnrecognizedFace) *Unrecognized { + this := &Unrecognized{} + this.Field1 = that.GetField1() + return this +} + +type UnrecognizedWithInnerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetEmbedded() []*UnrecognizedWithInner_Inner + GetField2() *string +} + +func (this *UnrecognizedWithInner) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithInner) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithInnerFromFace(this) +} + +func (this *UnrecognizedWithInner) GetEmbedded() []*UnrecognizedWithInner_Inner { + return this.Embedded +} + +func (this *UnrecognizedWithInner) GetField2() *string { + return this.Field2 +} + +func NewUnrecognizedWithInnerFromFace(that UnrecognizedWithInnerFace) *UnrecognizedWithInner { + this := &UnrecognizedWithInner{} + this.Embedded = that.GetEmbedded() + this.Field2 = that.GetField2() + return this +} + +type UnrecognizedWithInner_InnerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *uint32 +} + +func (this *UnrecognizedWithInner_Inner) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithInner_Inner) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithInner_InnerFromFace(this) +} + +func (this *UnrecognizedWithInner_Inner) GetField1() *uint32 { + return this.Field1 +} + +func NewUnrecognizedWithInner_InnerFromFace(that UnrecognizedWithInner_InnerFace) *UnrecognizedWithInner_Inner { + this := &UnrecognizedWithInner_Inner{} + this.Field1 = that.GetField1() + return this +} + +type UnrecognizedWithEmbedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetUnrecognizedWithEmbed_Embedded() UnrecognizedWithEmbed_Embedded + GetField2() *string +} + +func (this *UnrecognizedWithEmbed) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithEmbed) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithEmbedFromFace(this) +} + +func (this *UnrecognizedWithEmbed) GetUnrecognizedWithEmbed_Embedded() UnrecognizedWithEmbed_Embedded { + return this.UnrecognizedWithEmbed_Embedded +} + +func (this *UnrecognizedWithEmbed) GetField2() *string { + return this.Field2 +} + +func NewUnrecognizedWithEmbedFromFace(that UnrecognizedWithEmbedFace) *UnrecognizedWithEmbed { + this := &UnrecognizedWithEmbed{} + this.UnrecognizedWithEmbed_Embedded = that.GetUnrecognizedWithEmbed_Embedded() + this.Field2 = that.GetField2() + return this +} + +type UnrecognizedWithEmbed_EmbeddedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *uint32 +} + +func (this *UnrecognizedWithEmbed_Embedded) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithEmbed_Embedded) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithEmbed_EmbeddedFromFace(this) +} + +func (this *UnrecognizedWithEmbed_Embedded) GetField1() *uint32 { + return this.Field1 +} + +func NewUnrecognizedWithEmbed_EmbeddedFromFace(that UnrecognizedWithEmbed_EmbeddedFace) *UnrecognizedWithEmbed_Embedded { + this := &UnrecognizedWithEmbed_Embedded{} + this.Field1 = that.GetField1() + return this +} + +func (this *NidOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NidOptNative{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinOptNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+valueToGoStringThetest(this.Field8, "int64")+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+valueToGoStringThetest(this.Field9, "uint32")+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+valueToGoStringThetest(this.Field10, "int32")+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+valueToGoStringThetest(this.Field11, "uint64")+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+valueToGoStringThetest(this.Field12, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NidRepNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinRepNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepPackedNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 17) + s = append(s, "&test.NidRepPackedNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepPackedNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 17) + s = append(s, "&test.NinRepPackedNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NidOptStruct{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + s = append(s, "Field3: "+strings.Replace(this.Field3.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field4: "+strings.Replace(this.Field4.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + s = append(s, "Field8: "+strings.Replace(this.Field8.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NinOptStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NidRepStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+strings.Replace(fmt.Sprintf("%#v", this.Field3), `&`, ``, 1)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+strings.Replace(fmt.Sprintf("%#v", this.Field4), `&`, ``, 1)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+strings.Replace(fmt.Sprintf("%#v", this.Field8), `&`, ``, 1)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NinRepStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidEmbeddedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NidEmbeddedStruct{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + s = append(s, "Field200: "+strings.Replace(this.Field200.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field210: "+fmt.Sprintf("%#v", this.Field210)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinEmbeddedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinEmbeddedStruct{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.Field200 != nil { + s = append(s, "Field200: "+fmt.Sprintf("%#v", this.Field200)+",\n") + } + if this.Field210 != nil { + s = append(s, "Field210: "+valueToGoStringThetest(this.Field210, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidNestedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidNestedStruct{") + s = append(s, "Field1: "+strings.Replace(this.Field1.GoString(), `&`, ``, 1)+",\n") + if this.Field2 != nil { + s = append(s, "Field2: "+strings.Replace(fmt.Sprintf("%#v", this.Field2), `&`, ``, 1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinNestedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinNestedStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidOptCustom{") + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomDash) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.CustomDash{") + if this.Value != nil { + s = append(s, "Value: "+valueToGoStringThetest(this.Value, "github_com_gogo_protobuf_test_custom_dash_type.Bytes")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinOptCustom{") + if this.Id != nil { + s = append(s, "Id: "+valueToGoStringThetest(this.Id, "Uuid")+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+valueToGoStringThetest(this.Value, "github_com_gogo_protobuf_test_custom.Uint128")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidRepCustom{") + if this.Id != nil { + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinRepCustom{") + if this.Id != nil { + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNativeUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 13) + s = append(s, "&test.NinOptNativeUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 13) + s = append(s, "&test.NinOptStructUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinEmbeddedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinEmbeddedStructUnion{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.Field200 != nil { + s = append(s, "Field200: "+fmt.Sprintf("%#v", this.Field200)+",\n") + } + if this.Field210 != nil { + s = append(s, "Field210: "+valueToGoStringThetest(this.Field210, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinNestedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinNestedStructUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Tree) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.Tree{") + if this.Or != nil { + s = append(s, "Or: "+fmt.Sprintf("%#v", this.Or)+",\n") + } + if this.And != nil { + s = append(s, "And: "+fmt.Sprintf("%#v", this.And)+",\n") + } + if this.Leaf != nil { + s = append(s, "Leaf: "+fmt.Sprintf("%#v", this.Leaf)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OrBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.OrBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AndBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.AndBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Leaf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.Leaf{") + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + s = append(s, "StrValue: "+fmt.Sprintf("%#v", this.StrValue)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DeepTree) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.DeepTree{") + if this.Down != nil { + s = append(s, "Down: "+fmt.Sprintf("%#v", this.Down)+",\n") + } + if this.And != nil { + s = append(s, "And: "+fmt.Sprintf("%#v", this.And)+",\n") + } + if this.Leaf != nil { + s = append(s, "Leaf: "+fmt.Sprintf("%#v", this.Leaf)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *ADeepBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.ADeepBranch{") + s = append(s, "Down: "+strings.Replace(this.Down.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AndDeepBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.AndDeepBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DeepLeaf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.DeepLeaf{") + s = append(s, "Tree: "+strings.Replace(this.Tree.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Nil) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 4) + s = append(s, "&test.Nil{") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NidOptEnum{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinOptEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.TheTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NidRepEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinRepEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptEnumDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinOptEnumDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.TheTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AnotherNinOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.AnotherNinOptEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.AnotherTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AnotherNinOptEnumDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.AnotherNinOptEnumDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.AnotherTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Timer) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.Timer{") + s = append(s, "Time1: "+fmt.Sprintf("%#v", this.Time1)+",\n") + s = append(s, "Time2: "+fmt.Sprintf("%#v", this.Time2)+",\n") + s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MyExtendable) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.MyExtendable{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringThetest(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OtherExtenable) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.OtherExtenable{") + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "int64")+",\n") + } + if this.M != nil { + s = append(s, "M: "+fmt.Sprintf("%#v", this.M)+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringThetest(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&test.NestedDefinition{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.EnumField != nil { + s = append(s, "EnumField: "+valueToGoStringThetest(this.EnumField, "test.NestedDefinition_NestedEnum")+",\n") + } + if this.NNM != nil { + s = append(s, "NNM: "+fmt.Sprintf("%#v", this.NNM)+",\n") + } + if this.NM != nil { + s = append(s, "NM: "+fmt.Sprintf("%#v", this.NM)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition_NestedMessage) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NestedDefinition_NestedMessage{") + if this.NestedField1 != nil { + s = append(s, "NestedField1: "+valueToGoStringThetest(this.NestedField1, "uint64")+",\n") + } + if this.NNM != nil { + s = append(s, "NNM: "+fmt.Sprintf("%#v", this.NNM)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NestedDefinition_NestedMessage_NestedNestedMsg{") + if this.NestedNestedField1 != nil { + s = append(s, "NestedNestedField1: "+valueToGoStringThetest(this.NestedNestedField1, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedScope) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NestedScope{") + if this.A != nil { + s = append(s, "A: "+fmt.Sprintf("%#v", this.A)+",\n") + } + if this.B != nil { + s = append(s, "B: "+valueToGoStringThetest(this.B, "test.NestedDefinition_NestedEnum")+",\n") + } + if this.C != nil { + s = append(s, "C: "+fmt.Sprintf("%#v", this.C)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNativeDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinOptNativeDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+valueToGoStringThetest(this.Field8, "int64")+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+valueToGoStringThetest(this.Field9, "uint32")+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+valueToGoStringThetest(this.Field10, "int32")+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+valueToGoStringThetest(this.Field11, "uint64")+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+valueToGoStringThetest(this.Field12, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomContainer) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.CustomContainer{") + s = append(s, "CustomStruct: "+strings.Replace(this.CustomStruct.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNidOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNidOptNative{") + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + s = append(s, "FieldE: "+fmt.Sprintf("%#v", this.FieldE)+",\n") + s = append(s, "FieldF: "+fmt.Sprintf("%#v", this.FieldF)+",\n") + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + s = append(s, "FieldH: "+fmt.Sprintf("%#v", this.FieldH)+",\n") + s = append(s, "FieldI: "+fmt.Sprintf("%#v", this.FieldI)+",\n") + s = append(s, "FieldJ: "+fmt.Sprintf("%#v", this.FieldJ)+",\n") + s = append(s, "FieldK: "+fmt.Sprintf("%#v", this.FieldK)+",\n") + s = append(s, "FieldL: "+fmt.Sprintf("%#v", this.FieldL)+",\n") + s = append(s, "FieldM: "+fmt.Sprintf("%#v", this.FieldM)+",\n") + s = append(s, "FieldN: "+fmt.Sprintf("%#v", this.FieldN)+",\n") + s = append(s, "FieldO: "+fmt.Sprintf("%#v", this.FieldO)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNinOptNative{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "float64")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "float32")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+valueToGoStringThetest(this.FieldC, "int32")+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+valueToGoStringThetest(this.FieldD, "int64")+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+valueToGoStringThetest(this.FieldE, "uint32")+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+valueToGoStringThetest(this.FieldF, "uint64")+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+valueToGoStringThetest(this.FieldG, "int32")+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+valueToGoStringThetest(this.FieldH, "int64")+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+valueToGoStringThetest(this.FieldI, "uint32")+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+valueToGoStringThetest(this.FieldJ, "int32")+",\n") + } + if this.FieldK != nil { + s = append(s, "FieldK: "+valueToGoStringThetest(this.FieldK, "uint64")+",\n") + } + if this.FielL != nil { + s = append(s, "FielL: "+valueToGoStringThetest(this.FielL, "int64")+",\n") + } + if this.FieldM != nil { + s = append(s, "FieldM: "+valueToGoStringThetest(this.FieldM, "bool")+",\n") + } + if this.FieldN != nil { + s = append(s, "FieldN: "+valueToGoStringThetest(this.FieldN, "string")+",\n") + } + if this.FieldO != nil { + s = append(s, "FieldO: "+valueToGoStringThetest(this.FieldO, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNinRepNative{") + if this.FieldA != nil { + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+fmt.Sprintf("%#v", this.FieldE)+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+fmt.Sprintf("%#v", this.FieldF)+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+fmt.Sprintf("%#v", this.FieldH)+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+fmt.Sprintf("%#v", this.FieldI)+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+fmt.Sprintf("%#v", this.FieldJ)+",\n") + } + if this.FieldK != nil { + s = append(s, "FieldK: "+fmt.Sprintf("%#v", this.FieldK)+",\n") + } + if this.FieldL != nil { + s = append(s, "FieldL: "+fmt.Sprintf("%#v", this.FieldL)+",\n") + } + if this.FieldM != nil { + s = append(s, "FieldM: "+fmt.Sprintf("%#v", this.FieldM)+",\n") + } + if this.FieldN != nil { + s = append(s, "FieldN: "+fmt.Sprintf("%#v", this.FieldN)+",\n") + } + if this.FieldO != nil { + s = append(s, "FieldO: "+fmt.Sprintf("%#v", this.FieldO)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.CustomNameNinStruct{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "float64")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "float32")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+valueToGoStringThetest(this.FieldE, "uint64")+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+valueToGoStringThetest(this.FieldF, "int32")+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+valueToGoStringThetest(this.FieldH, "bool")+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+valueToGoStringThetest(this.FieldI, "string")+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+valueToGoStringThetest(this.FieldJ, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameCustomType) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&test.CustomNameCustomType{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "Uuid")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "github_com_gogo_protobuf_test_custom.Uint128")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinEmbeddedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.CustomNameNinEmbeddedStructUnion{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.FieldA != nil { + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.CustomNameEnum{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "test.TheTestEnum")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NoExtensionsMap) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NoExtensionsMap{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+fmt.Sprintf("%#v", this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Unrecognized) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.Unrecognized{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "string")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithInner) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.UnrecognizedWithInner{") + if this.Embedded != nil { + s = append(s, "Embedded: "+fmt.Sprintf("%#v", this.Embedded)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithInner_Inner) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.UnrecognizedWithInner_Inner{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "uint32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithEmbed) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.UnrecognizedWithEmbed{") + s = append(s, "UnrecognizedWithEmbed_Embedded: "+strings.Replace(this.UnrecognizedWithEmbed_Embedded.GoString(), `&`, ``, 1)+",\n") + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithEmbed_Embedded) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.UnrecognizedWithEmbed_Embedded{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "uint32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringThetest(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringThetest(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedNidOptNative(r randyThetest, easy bool) *NidOptNative { + this := &NidOptNative{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + this.Field5 = uint32(r.Uint32()) + this.Field6 = uint64(uint64(r.Uint32())) + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + this.Field9 = uint32(r.Uint32()) + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + this.Field11 = uint64(uint64(r.Uint32())) + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + this.Field13 = bool(bool(r.Intn(2) == 0)) + this.Field14 = randStringThetest(r) + v1 := r.Intn(100) + this.Field15 = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinOptNative(r randyThetest, easy bool) *NinOptNative { + this := &NinOptNative{} + if r.Intn(10) != 0 { + v2 := float64(r.Float64()) + if r.Intn(2) == 0 { + v2 *= -1 + } + this.Field1 = &v2 + } + if r.Intn(10) != 0 { + v3 := float32(r.Float32()) + if r.Intn(2) == 0 { + v3 *= -1 + } + this.Field2 = &v3 + } + if r.Intn(10) != 0 { + v4 := int32(r.Int31()) + if r.Intn(2) == 0 { + v4 *= -1 + } + this.Field3 = &v4 + } + if r.Intn(10) != 0 { + v5 := int64(r.Int63()) + if r.Intn(2) == 0 { + v5 *= -1 + } + this.Field4 = &v5 + } + if r.Intn(10) != 0 { + v6 := uint32(r.Uint32()) + this.Field5 = &v6 + } + if r.Intn(10) != 0 { + v7 := uint64(uint64(r.Uint32())) + this.Field6 = &v7 + } + if r.Intn(10) != 0 { + v8 := int32(r.Int31()) + if r.Intn(2) == 0 { + v8 *= -1 + } + this.Field7 = &v8 + } + if r.Intn(10) != 0 { + v9 := int64(r.Int63()) + if r.Intn(2) == 0 { + v9 *= -1 + } + this.Field8 = &v9 + } + if r.Intn(10) != 0 { + v10 := uint32(r.Uint32()) + this.Field9 = &v10 + } + if r.Intn(10) != 0 { + v11 := int32(r.Int31()) + if r.Intn(2) == 0 { + v11 *= -1 + } + this.Field10 = &v11 + } + if r.Intn(10) != 0 { + v12 := uint64(uint64(r.Uint32())) + this.Field11 = &v12 + } + if r.Intn(10) != 0 { + v13 := int64(r.Int63()) + if r.Intn(2) == 0 { + v13 *= -1 + } + this.Field12 = &v13 + } + if r.Intn(10) != 0 { + v14 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v14 + } + if r.Intn(10) != 0 { + v15 := randStringThetest(r) + this.Field14 = &v15 + } + if r.Intn(10) != 0 { + v16 := r.Intn(100) + this.Field15 = make([]byte, v16) + for i := 0; i < v16; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepNative(r randyThetest, easy bool) *NidRepNative { + this := &NidRepNative{} + if r.Intn(10) != 0 { + v17 := r.Intn(100) + this.Field1 = make([]float64, v17) + for i := 0; i < v17; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v18 := r.Intn(100) + this.Field2 = make([]float32, v18) + for i := 0; i < v18; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v19 := r.Intn(100) + this.Field3 = make([]int32, v19) + for i := 0; i < v19; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v20 := r.Intn(100) + this.Field4 = make([]int64, v20) + for i := 0; i < v20; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v21 := r.Intn(100) + this.Field5 = make([]uint32, v21) + for i := 0; i < v21; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v22 := r.Intn(100) + this.Field6 = make([]uint64, v22) + for i := 0; i < v22; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v23 := r.Intn(100) + this.Field7 = make([]int32, v23) + for i := 0; i < v23; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v24 := r.Intn(100) + this.Field8 = make([]int64, v24) + for i := 0; i < v24; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v25 := r.Intn(100) + this.Field9 = make([]uint32, v25) + for i := 0; i < v25; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v26 := r.Intn(100) + this.Field10 = make([]int32, v26) + for i := 0; i < v26; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v27 := r.Intn(100) + this.Field11 = make([]uint64, v27) + for i := 0; i < v27; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v28 := r.Intn(100) + this.Field12 = make([]int64, v28) + for i := 0; i < v28; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(100) + this.Field13 = make([]bool, v29) + for i := 0; i < v29; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v30 := r.Intn(10) + this.Field14 = make([]string, v30) + for i := 0; i < v30; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v31 := r.Intn(100) + this.Field15 = make([][]byte, v31) + for i := 0; i < v31; i++ { + v32 := r.Intn(100) + this.Field15[i] = make([]byte, v32) + for j := 0; j < v32; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinRepNative(r randyThetest, easy bool) *NinRepNative { + this := &NinRepNative{} + if r.Intn(10) != 0 { + v33 := r.Intn(100) + this.Field1 = make([]float64, v33) + for i := 0; i < v33; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v34 := r.Intn(100) + this.Field2 = make([]float32, v34) + for i := 0; i < v34; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v35 := r.Intn(100) + this.Field3 = make([]int32, v35) + for i := 0; i < v35; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v36 := r.Intn(100) + this.Field4 = make([]int64, v36) + for i := 0; i < v36; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v37 := r.Intn(100) + this.Field5 = make([]uint32, v37) + for i := 0; i < v37; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v38 := r.Intn(100) + this.Field6 = make([]uint64, v38) + for i := 0; i < v38; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v39 := r.Intn(100) + this.Field7 = make([]int32, v39) + for i := 0; i < v39; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v40 := r.Intn(100) + this.Field8 = make([]int64, v40) + for i := 0; i < v40; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v41 := r.Intn(100) + this.Field9 = make([]uint32, v41) + for i := 0; i < v41; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v42 := r.Intn(100) + this.Field10 = make([]int32, v42) + for i := 0; i < v42; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v43 := r.Intn(100) + this.Field11 = make([]uint64, v43) + for i := 0; i < v43; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v44 := r.Intn(100) + this.Field12 = make([]int64, v44) + for i := 0; i < v44; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v45 := r.Intn(100) + this.Field13 = make([]bool, v45) + for i := 0; i < v45; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v46 := r.Intn(10) + this.Field14 = make([]string, v46) + for i := 0; i < v46; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v47 := r.Intn(100) + this.Field15 = make([][]byte, v47) + for i := 0; i < v47; i++ { + v48 := r.Intn(100) + this.Field15[i] = make([]byte, v48) + for j := 0; j < v48; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepPackedNative(r randyThetest, easy bool) *NidRepPackedNative { + this := &NidRepPackedNative{} + if r.Intn(10) != 0 { + v49 := r.Intn(100) + this.Field1 = make([]float64, v49) + for i := 0; i < v49; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v50 := r.Intn(100) + this.Field2 = make([]float32, v50) + for i := 0; i < v50; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v51 := r.Intn(100) + this.Field3 = make([]int32, v51) + for i := 0; i < v51; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v52 := r.Intn(100) + this.Field4 = make([]int64, v52) + for i := 0; i < v52; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v53 := r.Intn(100) + this.Field5 = make([]uint32, v53) + for i := 0; i < v53; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v54 := r.Intn(100) + this.Field6 = make([]uint64, v54) + for i := 0; i < v54; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v55 := r.Intn(100) + this.Field7 = make([]int32, v55) + for i := 0; i < v55; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v56 := r.Intn(100) + this.Field8 = make([]int64, v56) + for i := 0; i < v56; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v57 := r.Intn(100) + this.Field9 = make([]uint32, v57) + for i := 0; i < v57; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v58 := r.Intn(100) + this.Field10 = make([]int32, v58) + for i := 0; i < v58; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v59 := r.Intn(100) + this.Field11 = make([]uint64, v59) + for i := 0; i < v59; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v60 := r.Intn(100) + this.Field12 = make([]int64, v60) + for i := 0; i < v60; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v61 := r.Intn(100) + this.Field13 = make([]bool, v61) + for i := 0; i < v61; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 14) + } + return this +} + +func NewPopulatedNinRepPackedNative(r randyThetest, easy bool) *NinRepPackedNative { + this := &NinRepPackedNative{} + if r.Intn(10) != 0 { + v62 := r.Intn(100) + this.Field1 = make([]float64, v62) + for i := 0; i < v62; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v63 := r.Intn(100) + this.Field2 = make([]float32, v63) + for i := 0; i < v63; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v64 := r.Intn(100) + this.Field3 = make([]int32, v64) + for i := 0; i < v64; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v65 := r.Intn(100) + this.Field4 = make([]int64, v65) + for i := 0; i < v65; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v66 := r.Intn(100) + this.Field5 = make([]uint32, v66) + for i := 0; i < v66; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v67 := r.Intn(100) + this.Field6 = make([]uint64, v67) + for i := 0; i < v67; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v68 := r.Intn(100) + this.Field7 = make([]int32, v68) + for i := 0; i < v68; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v69 := r.Intn(100) + this.Field8 = make([]int64, v69) + for i := 0; i < v69; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v70 := r.Intn(100) + this.Field9 = make([]uint32, v70) + for i := 0; i < v70; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v71 := r.Intn(100) + this.Field10 = make([]int32, v71) + for i := 0; i < v71; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v72 := r.Intn(100) + this.Field11 = make([]uint64, v72) + for i := 0; i < v72; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v73 := r.Intn(100) + this.Field12 = make([]int64, v73) + for i := 0; i < v73; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v74 := r.Intn(100) + this.Field13 = make([]bool, v74) + for i := 0; i < v74; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 14) + } + return this +} + +func NewPopulatedNidOptStruct(r randyThetest, easy bool) *NidOptStruct { + this := &NidOptStruct{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + v75 := NewPopulatedNidOptNative(r, easy) + this.Field3 = *v75 + v76 := NewPopulatedNinOptNative(r, easy) + this.Field4 = *v76 + this.Field6 = uint64(uint64(r.Uint32())) + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + v77 := NewPopulatedNidOptNative(r, easy) + this.Field8 = *v77 + this.Field13 = bool(bool(r.Intn(2) == 0)) + this.Field14 = randStringThetest(r) + v78 := r.Intn(100) + this.Field15 = make([]byte, v78) + for i := 0; i < v78; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinOptStruct(r randyThetest, easy bool) *NinOptStruct { + this := &NinOptStruct{} + if r.Intn(10) != 0 { + v79 := float64(r.Float64()) + if r.Intn(2) == 0 { + v79 *= -1 + } + this.Field1 = &v79 + } + if r.Intn(10) != 0 { + v80 := float32(r.Float32()) + if r.Intn(2) == 0 { + v80 *= -1 + } + this.Field2 = &v80 + } + if r.Intn(10) != 0 { + this.Field3 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + this.Field4 = NewPopulatedNinOptNative(r, easy) + } + if r.Intn(10) != 0 { + v81 := uint64(uint64(r.Uint32())) + this.Field6 = &v81 + } + if r.Intn(10) != 0 { + v82 := int32(r.Int31()) + if r.Intn(2) == 0 { + v82 *= -1 + } + this.Field7 = &v82 + } + if r.Intn(10) != 0 { + this.Field8 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v83 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v83 + } + if r.Intn(10) != 0 { + v84 := randStringThetest(r) + this.Field14 = &v84 + } + if r.Intn(10) != 0 { + v85 := r.Intn(100) + this.Field15 = make([]byte, v85) + for i := 0; i < v85; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepStruct(r randyThetest, easy bool) *NidRepStruct { + this := &NidRepStruct{} + if r.Intn(10) != 0 { + v86 := r.Intn(100) + this.Field1 = make([]float64, v86) + for i := 0; i < v86; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v87 := r.Intn(100) + this.Field2 = make([]float32, v87) + for i := 0; i < v87; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v88 := r.Intn(10) + this.Field3 = make([]NidOptNative, v88) + for i := 0; i < v88; i++ { + v89 := NewPopulatedNidOptNative(r, easy) + this.Field3[i] = *v89 + } + } + if r.Intn(10) != 0 { + v90 := r.Intn(10) + this.Field4 = make([]NinOptNative, v90) + for i := 0; i < v90; i++ { + v91 := NewPopulatedNinOptNative(r, easy) + this.Field4[i] = *v91 + } + } + if r.Intn(10) != 0 { + v92 := r.Intn(100) + this.Field6 = make([]uint64, v92) + for i := 0; i < v92; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v93 := r.Intn(100) + this.Field7 = make([]int32, v93) + for i := 0; i < v93; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v94 := r.Intn(10) + this.Field8 = make([]NidOptNative, v94) + for i := 0; i < v94; i++ { + v95 := NewPopulatedNidOptNative(r, easy) + this.Field8[i] = *v95 + } + } + if r.Intn(10) != 0 { + v96 := r.Intn(100) + this.Field13 = make([]bool, v96) + for i := 0; i < v96; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v97 := r.Intn(10) + this.Field14 = make([]string, v97) + for i := 0; i < v97; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v98 := r.Intn(100) + this.Field15 = make([][]byte, v98) + for i := 0; i < v98; i++ { + v99 := r.Intn(100) + this.Field15[i] = make([]byte, v99) + for j := 0; j < v99; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinRepStruct(r randyThetest, easy bool) *NinRepStruct { + this := &NinRepStruct{} + if r.Intn(10) != 0 { + v100 := r.Intn(100) + this.Field1 = make([]float64, v100) + for i := 0; i < v100; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v101 := r.Intn(100) + this.Field2 = make([]float32, v101) + for i := 0; i < v101; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v102 := r.Intn(10) + this.Field3 = make([]*NidOptNative, v102) + for i := 0; i < v102; i++ { + this.Field3[i] = NewPopulatedNidOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v103 := r.Intn(10) + this.Field4 = make([]*NinOptNative, v103) + for i := 0; i < v103; i++ { + this.Field4[i] = NewPopulatedNinOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v104 := r.Intn(100) + this.Field6 = make([]uint64, v104) + for i := 0; i < v104; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v105 := r.Intn(100) + this.Field7 = make([]int32, v105) + for i := 0; i < v105; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v106 := r.Intn(10) + this.Field8 = make([]*NidOptNative, v106) + for i := 0; i < v106; i++ { + this.Field8[i] = NewPopulatedNidOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v107 := r.Intn(100) + this.Field13 = make([]bool, v107) + for i := 0; i < v107; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v108 := r.Intn(10) + this.Field14 = make([]string, v108) + for i := 0; i < v108; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v109 := r.Intn(100) + this.Field15 = make([][]byte, v109) + for i := 0; i < v109; i++ { + v110 := r.Intn(100) + this.Field15[i] = make([]byte, v110) + for j := 0; j < v110; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidEmbeddedStruct(r randyThetest, easy bool) *NidEmbeddedStruct { + this := &NidEmbeddedStruct{} + if r.Intn(10) != 0 { + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + } + v111 := NewPopulatedNidOptNative(r, easy) + this.Field200 = *v111 + this.Field210 = bool(bool(r.Intn(2) == 0)) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 211) + } + return this +} + +func NewPopulatedNinEmbeddedStruct(r randyThetest, easy bool) *NinEmbeddedStruct { + this := &NinEmbeddedStruct{} + if r.Intn(10) != 0 { + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + this.Field200 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v112 := bool(bool(r.Intn(2) == 0)) + this.Field210 = &v112 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 211) + } + return this +} + +func NewPopulatedNidNestedStruct(r randyThetest, easy bool) *NidNestedStruct { + this := &NidNestedStruct{} + v113 := NewPopulatedNidOptStruct(r, easy) + this.Field1 = *v113 + if r.Intn(10) != 0 { + v114 := r.Intn(10) + this.Field2 = make([]NidRepStruct, v114) + for i := 0; i < v114; i++ { + v115 := NewPopulatedNidRepStruct(r, easy) + this.Field2[i] = *v115 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinNestedStruct(r randyThetest, easy bool) *NinNestedStruct { + this := &NinNestedStruct{} + if r.Intn(10) != 0 { + this.Field1 = NewPopulatedNinOptStruct(r, easy) + } + if r.Intn(10) != 0 { + v116 := r.Intn(10) + this.Field2 = make([]*NinRepStruct, v116) + for i := 0; i < v116; i++ { + this.Field2[i] = NewPopulatedNinRepStruct(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNidOptCustom(r randyThetest, easy bool) *NidOptCustom { + this := &NidOptCustom{} + v117 := NewPopulatedUuid(r) + this.Id = *v117 + v118 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value = *v118 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedCustomDash(r randyThetest, easy bool) *CustomDash { + this := &CustomDash{} + if r.Intn(10) != 0 { + this.Value = github_com_gogo_protobuf_test_custom_dash_type.NewPopulatedBytes(r) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptCustom(r randyThetest, easy bool) *NinOptCustom { + this := &NinOptCustom{} + if r.Intn(10) != 0 { + this.Id = NewPopulatedUuid(r) + } + if r.Intn(10) != 0 { + this.Value = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNidRepCustom(r randyThetest, easy bool) *NidRepCustom { + this := &NidRepCustom{} + if r.Intn(10) != 0 { + v119 := r.Intn(10) + this.Id = make([]Uuid, v119) + for i := 0; i < v119; i++ { + v120 := NewPopulatedUuid(r) + this.Id[i] = *v120 + } + } + if r.Intn(10) != 0 { + v121 := r.Intn(10) + this.Value = make([]github_com_gogo_protobuf_test_custom.Uint128, v121) + for i := 0; i < v121; i++ { + v122 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value[i] = *v122 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinRepCustom(r randyThetest, easy bool) *NinRepCustom { + this := &NinRepCustom{} + if r.Intn(10) != 0 { + v123 := r.Intn(10) + this.Id = make([]Uuid, v123) + for i := 0; i < v123; i++ { + v124 := NewPopulatedUuid(r) + this.Id[i] = *v124 + } + } + if r.Intn(10) != 0 { + v125 := r.Intn(10) + this.Value = make([]github_com_gogo_protobuf_test_custom.Uint128, v125) + for i := 0; i < v125; i++ { + v126 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value[i] = *v126 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinOptNativeUnion(r randyThetest, easy bool) *NinOptNativeUnion { + this := &NinOptNativeUnion{} + fieldNum := r.Intn(9) + switch fieldNum { + case 0: + v127 := float64(r.Float64()) + if r.Intn(2) == 0 { + v127 *= -1 + } + this.Field1 = &v127 + case 1: + v128 := float32(r.Float32()) + if r.Intn(2) == 0 { + v128 *= -1 + } + this.Field2 = &v128 + case 2: + v129 := int32(r.Int31()) + if r.Intn(2) == 0 { + v129 *= -1 + } + this.Field3 = &v129 + case 3: + v130 := int64(r.Int63()) + if r.Intn(2) == 0 { + v130 *= -1 + } + this.Field4 = &v130 + case 4: + v131 := uint32(r.Uint32()) + this.Field5 = &v131 + case 5: + v132 := uint64(uint64(r.Uint32())) + this.Field6 = &v132 + case 6: + v133 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v133 + case 7: + v134 := randStringThetest(r) + this.Field14 = &v134 + case 8: + v135 := r.Intn(100) + this.Field15 = make([]byte, v135) + for i := 0; i < v135; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + return this +} + +func NewPopulatedNinOptStructUnion(r randyThetest, easy bool) *NinOptStructUnion { + this := &NinOptStructUnion{} + fieldNum := r.Intn(9) + switch fieldNum { + case 0: + v136 := float64(r.Float64()) + if r.Intn(2) == 0 { + v136 *= -1 + } + this.Field1 = &v136 + case 1: + v137 := float32(r.Float32()) + if r.Intn(2) == 0 { + v137 *= -1 + } + this.Field2 = &v137 + case 2: + this.Field3 = NewPopulatedNidOptNative(r, easy) + case 3: + this.Field4 = NewPopulatedNinOptNative(r, easy) + case 4: + v138 := uint64(uint64(r.Uint32())) + this.Field6 = &v138 + case 5: + v139 := int32(r.Int31()) + if r.Intn(2) == 0 { + v139 *= -1 + } + this.Field7 = &v139 + case 6: + v140 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v140 + case 7: + v141 := randStringThetest(r) + this.Field14 = &v141 + case 8: + v142 := r.Intn(100) + this.Field15 = make([]byte, v142) + for i := 0; i < v142; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + return this +} + +func NewPopulatedNinEmbeddedStructUnion(r randyThetest, easy bool) *NinEmbeddedStructUnion { + this := &NinEmbeddedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + case 1: + this.Field200 = NewPopulatedNinOptNative(r, easy) + case 2: + v143 := bool(bool(r.Intn(2) == 0)) + this.Field210 = &v143 + } + return this +} + +func NewPopulatedNinNestedStructUnion(r randyThetest, easy bool) *NinNestedStructUnion { + this := &NinNestedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.Field1 = NewPopulatedNinOptNativeUnion(r, easy) + case 1: + this.Field2 = NewPopulatedNinOptStructUnion(r, easy) + case 2: + this.Field3 = NewPopulatedNinEmbeddedStructUnion(r, easy) + } + return this +} + +func NewPopulatedTree(r randyThetest, easy bool) *Tree { + this := &Tree{} + fieldNum := r.Intn(102) + switch fieldNum { + case 0: + this.Or = NewPopulatedOrBranch(r, easy) + case 1: + this.And = NewPopulatedAndBranch(r, easy) + case 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101: + this.Leaf = NewPopulatedLeaf(r, easy) + } + return this +} + +func NewPopulatedOrBranch(r randyThetest, easy bool) *OrBranch { + this := &OrBranch{} + v144 := NewPopulatedTree(r, easy) + this.Left = *v144 + v145 := NewPopulatedTree(r, easy) + this.Right = *v145 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedAndBranch(r randyThetest, easy bool) *AndBranch { + this := &AndBranch{} + v146 := NewPopulatedTree(r, easy) + this.Left = *v146 + v147 := NewPopulatedTree(r, easy) + this.Right = *v147 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedLeaf(r randyThetest, easy bool) *Leaf { + this := &Leaf{} + this.Value = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Value *= -1 + } + this.StrValue = randStringThetest(r) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedDeepTree(r randyThetest, easy bool) *DeepTree { + this := &DeepTree{} + fieldNum := r.Intn(102) + switch fieldNum { + case 0: + this.Down = NewPopulatedADeepBranch(r, easy) + case 1: + this.And = NewPopulatedAndDeepBranch(r, easy) + case 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101: + this.Leaf = NewPopulatedDeepLeaf(r, easy) + } + return this +} + +func NewPopulatedADeepBranch(r randyThetest, easy bool) *ADeepBranch { + this := &ADeepBranch{} + v148 := NewPopulatedDeepTree(r, easy) + this.Down = *v148 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedAndDeepBranch(r randyThetest, easy bool) *AndDeepBranch { + this := &AndDeepBranch{} + v149 := NewPopulatedDeepTree(r, easy) + this.Left = *v149 + v150 := NewPopulatedDeepTree(r, easy) + this.Right = *v150 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedDeepLeaf(r randyThetest, easy bool) *DeepLeaf { + this := &DeepLeaf{} + v151 := NewPopulatedTree(r, easy) + this.Tree = *v151 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNil(r randyThetest, easy bool) *Nil { + this := &Nil{} + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 1) + } + return this +} + +func NewPopulatedNidOptEnum(r randyThetest, easy bool) *NidOptEnum { + this := &NidOptEnum{} + this.Field1 = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptEnum(r randyThetest, easy bool) *NinOptEnum { + this := &NinOptEnum{} + if r.Intn(10) != 0 { + v152 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.Field1 = &v152 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNidRepEnum(r randyThetest, easy bool) *NidRepEnum { + this := &NidRepEnum{} + if r.Intn(10) != 0 { + v153 := r.Intn(10) + this.Field1 = make([]TheTestEnum, v153) + for i := 0; i < v153; i++ { + this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinRepEnum(r randyThetest, easy bool) *NinRepEnum { + this := &NinRepEnum{} + if r.Intn(10) != 0 { + v154 := r.Intn(10) + this.Field1 = make([]TheTestEnum, v154) + for i := 0; i < v154; i++ { + this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptEnumDefault(r randyThetest, easy bool) *NinOptEnumDefault { + this := &NinOptEnumDefault{} + if r.Intn(10) != 0 { + v155 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.Field1 = &v155 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedAnotherNinOptEnum(r randyThetest, easy bool) *AnotherNinOptEnum { + this := &AnotherNinOptEnum{} + if r.Intn(10) != 0 { + v156 := AnotherTestEnum([]int32{10, 11}[r.Intn(2)]) + this.Field1 = &v156 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedAnotherNinOptEnumDefault(r randyThetest, easy bool) *AnotherNinOptEnumDefault { + this := &AnotherNinOptEnumDefault{} + if r.Intn(10) != 0 { + v157 := AnotherTestEnum([]int32{10, 11}[r.Intn(2)]) + this.Field1 = &v157 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedTimer(r randyThetest, easy bool) *Timer { + this := &Timer{} + this.Time1 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Time1 *= -1 + } + this.Time2 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Time2 *= -1 + } + v158 := r.Intn(100) + this.Data = make([]byte, v158) + for i := 0; i < v158; i++ { + this.Data[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 4) + } + return this +} + +func NewPopulatedMyExtendable(r randyThetest, easy bool) *MyExtendable { + this := &MyExtendable{} + if r.Intn(10) != 0 { + v159 := int64(r.Int63()) + if r.Intn(2) == 0 { + v159 *= -1 + } + this.Field1 = &v159 + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + fieldNumber := r.Intn(100) + 100 + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 201) + } + return this +} + +func NewPopulatedOtherExtenable(r randyThetest, easy bool) *OtherExtenable { + this := &OtherExtenable{} + if r.Intn(10) != 0 { + v160 := int64(r.Int63()) + if r.Intn(2) == 0 { + v160 *= -1 + } + this.Field2 = &v160 + } + if r.Intn(10) != 0 { + v161 := int64(r.Int63()) + if r.Intn(2) == 0 { + v161 *= -1 + } + this.Field13 = &v161 + } + if r.Intn(10) != 0 { + this.M = NewPopulatedMyExtendable(r, easy) + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + eIndex := r.Intn(2) + fieldNumber := 0 + switch eIndex { + case 0: + fieldNumber = r.Intn(3) + 14 + case 1: + fieldNumber = r.Intn(3) + 10 + } + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 18) + } + return this +} + +func NewPopulatedNestedDefinition(r randyThetest, easy bool) *NestedDefinition { + this := &NestedDefinition{} + if r.Intn(10) != 0 { + v162 := int64(r.Int63()) + if r.Intn(2) == 0 { + v162 *= -1 + } + this.Field1 = &v162 + } + if r.Intn(10) != 0 { + v163 := NestedDefinition_NestedEnum([]int32{1}[r.Intn(1)]) + this.EnumField = &v163 + } + if r.Intn(10) != 0 { + this.NNM = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if r.Intn(10) != 0 { + this.NM = NewPopulatedNestedDefinition_NestedMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 5) + } + return this +} + +func NewPopulatedNestedDefinition_NestedMessage(r randyThetest, easy bool) *NestedDefinition_NestedMessage { + this := &NestedDefinition_NestedMessage{} + if r.Intn(10) != 0 { + v164 := uint64(uint64(r.Uint32())) + this.NestedField1 = &v164 + } + if r.Intn(10) != 0 { + this.NNM = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r randyThetest, easy bool) *NestedDefinition_NestedMessage_NestedNestedMsg { + this := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if r.Intn(10) != 0 { + v165 := randStringThetest(r) + this.NestedNestedField1 = &v165 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 11) + } + return this +} + +func NewPopulatedNestedScope(r randyThetest, easy bool) *NestedScope { + this := &NestedScope{} + if r.Intn(10) != 0 { + this.A = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if r.Intn(10) != 0 { + v166 := NestedDefinition_NestedEnum([]int32{1}[r.Intn(1)]) + this.B = &v166 + } + if r.Intn(10) != 0 { + this.C = NewPopulatedNestedDefinition_NestedMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 4) + } + return this +} + +func NewPopulatedNinOptNativeDefault(r randyThetest, easy bool) *NinOptNativeDefault { + this := &NinOptNativeDefault{} + if r.Intn(10) != 0 { + v167 := float64(r.Float64()) + if r.Intn(2) == 0 { + v167 *= -1 + } + this.Field1 = &v167 + } + if r.Intn(10) != 0 { + v168 := float32(r.Float32()) + if r.Intn(2) == 0 { + v168 *= -1 + } + this.Field2 = &v168 + } + if r.Intn(10) != 0 { + v169 := int32(r.Int31()) + if r.Intn(2) == 0 { + v169 *= -1 + } + this.Field3 = &v169 + } + if r.Intn(10) != 0 { + v170 := int64(r.Int63()) + if r.Intn(2) == 0 { + v170 *= -1 + } + this.Field4 = &v170 + } + if r.Intn(10) != 0 { + v171 := uint32(r.Uint32()) + this.Field5 = &v171 + } + if r.Intn(10) != 0 { + v172 := uint64(uint64(r.Uint32())) + this.Field6 = &v172 + } + if r.Intn(10) != 0 { + v173 := int32(r.Int31()) + if r.Intn(2) == 0 { + v173 *= -1 + } + this.Field7 = &v173 + } + if r.Intn(10) != 0 { + v174 := int64(r.Int63()) + if r.Intn(2) == 0 { + v174 *= -1 + } + this.Field8 = &v174 + } + if r.Intn(10) != 0 { + v175 := uint32(r.Uint32()) + this.Field9 = &v175 + } + if r.Intn(10) != 0 { + v176 := int32(r.Int31()) + if r.Intn(2) == 0 { + v176 *= -1 + } + this.Field10 = &v176 + } + if r.Intn(10) != 0 { + v177 := uint64(uint64(r.Uint32())) + this.Field11 = &v177 + } + if r.Intn(10) != 0 { + v178 := int64(r.Int63()) + if r.Intn(2) == 0 { + v178 *= -1 + } + this.Field12 = &v178 + } + if r.Intn(10) != 0 { + v179 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v179 + } + if r.Intn(10) != 0 { + v180 := randStringThetest(r) + this.Field14 = &v180 + } + if r.Intn(10) != 0 { + v181 := r.Intn(100) + this.Field15 = make([]byte, v181) + for i := 0; i < v181; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomContainer(r randyThetest, easy bool) *CustomContainer { + this := &CustomContainer{} + v182 := NewPopulatedNidOptCustom(r, easy) + this.CustomStruct = *v182 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedCustomNameNidOptNative(r randyThetest, easy bool) *CustomNameNidOptNative { + this := &CustomNameNidOptNative{} + this.FieldA = float64(r.Float64()) + if r.Intn(2) == 0 { + this.FieldA *= -1 + } + this.FieldB = float32(r.Float32()) + if r.Intn(2) == 0 { + this.FieldB *= -1 + } + this.FieldC = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldC *= -1 + } + this.FieldD = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldD *= -1 + } + this.FieldE = uint32(r.Uint32()) + this.FieldF = uint64(uint64(r.Uint32())) + this.FieldG = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldG *= -1 + } + this.FieldH = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldH *= -1 + } + this.FieldI = uint32(r.Uint32()) + this.FieldJ = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldJ *= -1 + } + this.FieldK = uint64(uint64(r.Uint32())) + this.FieldL = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldL *= -1 + } + this.FieldM = bool(bool(r.Intn(2) == 0)) + this.FieldN = randStringThetest(r) + v183 := r.Intn(100) + this.FieldO = make([]byte, v183) + for i := 0; i < v183; i++ { + this.FieldO[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinOptNative(r randyThetest, easy bool) *CustomNameNinOptNative { + this := &CustomNameNinOptNative{} + if r.Intn(10) != 0 { + v184 := float64(r.Float64()) + if r.Intn(2) == 0 { + v184 *= -1 + } + this.FieldA = &v184 + } + if r.Intn(10) != 0 { + v185 := float32(r.Float32()) + if r.Intn(2) == 0 { + v185 *= -1 + } + this.FieldB = &v185 + } + if r.Intn(10) != 0 { + v186 := int32(r.Int31()) + if r.Intn(2) == 0 { + v186 *= -1 + } + this.FieldC = &v186 + } + if r.Intn(10) != 0 { + v187 := int64(r.Int63()) + if r.Intn(2) == 0 { + v187 *= -1 + } + this.FieldD = &v187 + } + if r.Intn(10) != 0 { + v188 := uint32(r.Uint32()) + this.FieldE = &v188 + } + if r.Intn(10) != 0 { + v189 := uint64(uint64(r.Uint32())) + this.FieldF = &v189 + } + if r.Intn(10) != 0 { + v190 := int32(r.Int31()) + if r.Intn(2) == 0 { + v190 *= -1 + } + this.FieldG = &v190 + } + if r.Intn(10) != 0 { + v191 := int64(r.Int63()) + if r.Intn(2) == 0 { + v191 *= -1 + } + this.FieldH = &v191 + } + if r.Intn(10) != 0 { + v192 := uint32(r.Uint32()) + this.FieldI = &v192 + } + if r.Intn(10) != 0 { + v193 := int32(r.Int31()) + if r.Intn(2) == 0 { + v193 *= -1 + } + this.FieldJ = &v193 + } + if r.Intn(10) != 0 { + v194 := uint64(uint64(r.Uint32())) + this.FieldK = &v194 + } + if r.Intn(10) != 0 { + v195 := int64(r.Int63()) + if r.Intn(2) == 0 { + v195 *= -1 + } + this.FielL = &v195 + } + if r.Intn(10) != 0 { + v196 := bool(bool(r.Intn(2) == 0)) + this.FieldM = &v196 + } + if r.Intn(10) != 0 { + v197 := randStringThetest(r) + this.FieldN = &v197 + } + if r.Intn(10) != 0 { + v198 := r.Intn(100) + this.FieldO = make([]byte, v198) + for i := 0; i < v198; i++ { + this.FieldO[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinRepNative(r randyThetest, easy bool) *CustomNameNinRepNative { + this := &CustomNameNinRepNative{} + if r.Intn(10) != 0 { + v199 := r.Intn(100) + this.FieldA = make([]float64, v199) + for i := 0; i < v199; i++ { + this.FieldA[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.FieldA[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v200 := r.Intn(100) + this.FieldB = make([]float32, v200) + for i := 0; i < v200; i++ { + this.FieldB[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.FieldB[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v201 := r.Intn(100) + this.FieldC = make([]int32, v201) + for i := 0; i < v201; i++ { + this.FieldC[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldC[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v202 := r.Intn(100) + this.FieldD = make([]int64, v202) + for i := 0; i < v202; i++ { + this.FieldD[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldD[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v203 := r.Intn(100) + this.FieldE = make([]uint32, v203) + for i := 0; i < v203; i++ { + this.FieldE[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v204 := r.Intn(100) + this.FieldF = make([]uint64, v204) + for i := 0; i < v204; i++ { + this.FieldF[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v205 := r.Intn(100) + this.FieldG = make([]int32, v205) + for i := 0; i < v205; i++ { + this.FieldG[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldG[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v206 := r.Intn(100) + this.FieldH = make([]int64, v206) + for i := 0; i < v206; i++ { + this.FieldH[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldH[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v207 := r.Intn(100) + this.FieldI = make([]uint32, v207) + for i := 0; i < v207; i++ { + this.FieldI[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v208 := r.Intn(100) + this.FieldJ = make([]int32, v208) + for i := 0; i < v208; i++ { + this.FieldJ[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldJ[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v209 := r.Intn(100) + this.FieldK = make([]uint64, v209) + for i := 0; i < v209; i++ { + this.FieldK[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v210 := r.Intn(100) + this.FieldL = make([]int64, v210) + for i := 0; i < v210; i++ { + this.FieldL[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldL[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v211 := r.Intn(100) + this.FieldM = make([]bool, v211) + for i := 0; i < v211; i++ { + this.FieldM[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v212 := r.Intn(10) + this.FieldN = make([]string, v212) + for i := 0; i < v212; i++ { + this.FieldN[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v213 := r.Intn(100) + this.FieldO = make([][]byte, v213) + for i := 0; i < v213; i++ { + v214 := r.Intn(100) + this.FieldO[i] = make([]byte, v214) + for j := 0; j < v214; j++ { + this.FieldO[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinStruct(r randyThetest, easy bool) *CustomNameNinStruct { + this := &CustomNameNinStruct{} + if r.Intn(10) != 0 { + v215 := float64(r.Float64()) + if r.Intn(2) == 0 { + v215 *= -1 + } + this.FieldA = &v215 + } + if r.Intn(10) != 0 { + v216 := float32(r.Float32()) + if r.Intn(2) == 0 { + v216 *= -1 + } + this.FieldB = &v216 + } + if r.Intn(10) != 0 { + this.FieldC = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v217 := r.Intn(10) + this.FieldD = make([]*NinOptNative, v217) + for i := 0; i < v217; i++ { + this.FieldD[i] = NewPopulatedNinOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v218 := uint64(uint64(r.Uint32())) + this.FieldE = &v218 + } + if r.Intn(10) != 0 { + v219 := int32(r.Int31()) + if r.Intn(2) == 0 { + v219 *= -1 + } + this.FieldF = &v219 + } + if r.Intn(10) != 0 { + this.FieldG = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v220 := bool(bool(r.Intn(2) == 0)) + this.FieldH = &v220 + } + if r.Intn(10) != 0 { + v221 := randStringThetest(r) + this.FieldI = &v221 + } + if r.Intn(10) != 0 { + v222 := r.Intn(100) + this.FieldJ = make([]byte, v222) + for i := 0; i < v222; i++ { + this.FieldJ[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameCustomType(r randyThetest, easy bool) *CustomNameCustomType { + this := &CustomNameCustomType{} + if r.Intn(10) != 0 { + this.FieldA = NewPopulatedUuid(r) + } + if r.Intn(10) != 0 { + this.FieldB = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + } + if r.Intn(10) != 0 { + v223 := r.Intn(10) + this.FieldC = make([]Uuid, v223) + for i := 0; i < v223; i++ { + v224 := NewPopulatedUuid(r) + this.FieldC[i] = *v224 + } + } + if r.Intn(10) != 0 { + v225 := r.Intn(10) + this.FieldD = make([]github_com_gogo_protobuf_test_custom.Uint128, v225) + for i := 0; i < v225; i++ { + v226 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.FieldD[i] = *v226 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 5) + } + return this +} + +func NewPopulatedCustomNameNinEmbeddedStructUnion(r randyThetest, easy bool) *CustomNameNinEmbeddedStructUnion { + this := &CustomNameNinEmbeddedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + case 1: + this.FieldA = NewPopulatedNinOptNative(r, easy) + case 2: + v227 := bool(bool(r.Intn(2) == 0)) + this.FieldB = &v227 + } + return this +} + +func NewPopulatedCustomNameEnum(r randyThetest, easy bool) *CustomNameEnum { + this := &CustomNameEnum{} + if r.Intn(10) != 0 { + v228 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.FieldA = &v228 + } + if r.Intn(10) != 0 { + v229 := r.Intn(10) + this.FieldB = make([]TheTestEnum, v229) + for i := 0; i < v229; i++ { + this.FieldB[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNoExtensionsMap(r randyThetest, easy bool) *NoExtensionsMap { + this := &NoExtensionsMap{} + if r.Intn(10) != 0 { + v230 := int64(r.Int63()) + if r.Intn(2) == 0 { + v230 *= -1 + } + this.Field1 = &v230 + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + fieldNumber := r.Intn(100) + 100 + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 201) + } + return this +} + +func NewPopulatedUnrecognized(r randyThetest, easy bool) *Unrecognized { + this := &Unrecognized{} + if r.Intn(10) != 0 { + v231 := randStringThetest(r) + this.Field1 = &v231 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedUnrecognizedWithInner(r randyThetest, easy bool) *UnrecognizedWithInner { + this := &UnrecognizedWithInner{} + if r.Intn(10) != 0 { + v232 := r.Intn(10) + this.Embedded = make([]*UnrecognizedWithInner_Inner, v232) + for i := 0; i < v232; i++ { + this.Embedded[i] = NewPopulatedUnrecognizedWithInner_Inner(r, easy) + } + } + if r.Intn(10) != 0 { + v233 := randStringThetest(r) + this.Field2 = &v233 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedUnrecognizedWithInner_Inner(r randyThetest, easy bool) *UnrecognizedWithInner_Inner { + this := &UnrecognizedWithInner_Inner{} + if r.Intn(10) != 0 { + v234 := uint32(r.Uint32()) + this.Field1 = &v234 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedUnrecognizedWithEmbed(r randyThetest, easy bool) *UnrecognizedWithEmbed { + this := &UnrecognizedWithEmbed{} + v235 := NewPopulatedUnrecognizedWithEmbed_Embedded(r, easy) + this.UnrecognizedWithEmbed_Embedded = *v235 + if r.Intn(10) != 0 { + v236 := randStringThetest(r) + this.Field2 = &v236 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedUnrecognizedWithEmbed_Embedded(r randyThetest, easy bool) *UnrecognizedWithEmbed_Embedded { + this := &UnrecognizedWithEmbed_Embedded{} + if r.Intn(10) != 0 { + v237 := uint32(r.Uint32()) + this.Field1 = &v237 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +type randyThetest interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneThetest(r randyThetest) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringThetest(r randyThetest) string { + v238 := r.Intn(100) + tmps := make([]rune, v238) + for i := 0; i < v238; i++ { + tmps[i] = randUTF8RuneThetest(r) + } + return string(tmps) +} +func randUnrecognizedThetest(r randyThetest, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldThetest(data, r, fieldNumber, wire) + } + return data +} +func randFieldThetest(data []byte, r randyThetest, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateThetest(data, uint64(key)) + v239 := r.Int63() + if r.Intn(2) == 0 { + v239 *= -1 + } + data = encodeVarintPopulateThetest(data, uint64(v239)) + case 1: + data = encodeVarintPopulateThetest(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateThetest(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateThetest(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateThetest(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateThetest(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *NidOptNative) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + n += 1 + sovThetest(uint64(m.Field3)) + n += 1 + sovThetest(uint64(m.Field4)) + n += 1 + sovThetest(uint64(m.Field5)) + n += 1 + sovThetest(uint64(m.Field6)) + n += 1 + sozThetest(uint64(m.Field7)) + n += 1 + sozThetest(uint64(m.Field8)) + n += 5 + n += 5 + n += 9 + n += 9 + n += 2 + l = len(m.Field14) + n += 1 + l + sovThetest(uint64(l)) + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNative) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + n += 1 + sozThetest(uint64(*m.Field8)) + } + if m.Field9 != nil { + n += 5 + } + if m.Field10 != nil { + n += 5 + } + if m.Field11 != nil { + n += 9 + } + if m.Field12 != nil { + n += 9 + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field5) > 0 { + for _, e := range m.Field5 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field9) > 0 { + n += 5 * len(m.Field9) + } + if len(m.Field10) > 0 { + n += 5 * len(m.Field10) + } + if len(m.Field11) > 0 { + n += 9 * len(m.Field11) + } + if len(m.Field12) > 0 { + n += 9 * len(m.Field12) + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field5) > 0 { + for _, e := range m.Field5 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field9) > 0 { + n += 5 * len(m.Field9) + } + if len(m.Field10) > 0 { + n += 5 * len(m.Field10) + } + if len(m.Field11) > 0 { + n += 9 * len(m.Field11) + } + if len(m.Field12) > 0 { + n += 9 * len(m.Field12) + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepPackedNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 1 + sovThetest(uint64(len(m.Field1)*8)) + len(m.Field1)*8 + } + if len(m.Field2) > 0 { + n += 1 + sovThetest(uint64(len(m.Field2)*4)) + len(m.Field2)*4 + } + if len(m.Field3) > 0 { + l = 0 + for _, e := range m.Field3 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field4) > 0 { + l = 0 + for _, e := range m.Field4 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field5) > 0 { + l = 0 + for _, e := range m.Field5 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field6) > 0 { + l = 0 + for _, e := range m.Field6 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field7) > 0 { + l = 0 + for _, e := range m.Field7 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field8) > 0 { + l = 0 + for _, e := range m.Field8 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field9) > 0 { + n += 1 + sovThetest(uint64(len(m.Field9)*4)) + len(m.Field9)*4 + } + if len(m.Field10) > 0 { + n += 1 + sovThetest(uint64(len(m.Field10)*4)) + len(m.Field10)*4 + } + if len(m.Field11) > 0 { + n += 1 + sovThetest(uint64(len(m.Field11)*8)) + len(m.Field11)*8 + } + if len(m.Field12) > 0 { + n += 1 + sovThetest(uint64(len(m.Field12)*8)) + len(m.Field12)*8 + } + if len(m.Field13) > 0 { + n += 1 + sovThetest(uint64(len(m.Field13))) + len(m.Field13)*1 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepPackedNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 1 + sovThetest(uint64(len(m.Field1)*8)) + len(m.Field1)*8 + } + if len(m.Field2) > 0 { + n += 1 + sovThetest(uint64(len(m.Field2)*4)) + len(m.Field2)*4 + } + if len(m.Field3) > 0 { + l = 0 + for _, e := range m.Field3 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field4) > 0 { + l = 0 + for _, e := range m.Field4 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field5) > 0 { + l = 0 + for _, e := range m.Field5 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field6) > 0 { + l = 0 + for _, e := range m.Field6 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field7) > 0 { + l = 0 + for _, e := range m.Field7 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field8) > 0 { + l = 0 + for _, e := range m.Field8 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field9) > 0 { + n += 1 + sovThetest(uint64(len(m.Field9)*4)) + len(m.Field9)*4 + } + if len(m.Field10) > 0 { + n += 1 + sovThetest(uint64(len(m.Field10)*4)) + len(m.Field10)*4 + } + if len(m.Field11) > 0 { + n += 1 + sovThetest(uint64(len(m.Field11)*8)) + len(m.Field11)*8 + } + if len(m.Field12) > 0 { + n += 1 + sovThetest(uint64(len(m.Field12)*8)) + len(m.Field12)*8 + } + if len(m.Field13) > 0 { + n += 1 + sovThetest(uint64(len(m.Field13))) + len(m.Field13)*1 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptStruct) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + n += 1 + sovThetest(uint64(m.Field6)) + n += 1 + sozThetest(uint64(m.Field7)) + l = m.Field8.Size() + n += 1 + l + sovThetest(uint64(l)) + n += 2 + l = len(m.Field14) + n += 1 + l + sovThetest(uint64(l)) + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptStruct) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field4 != nil { + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + l = m.Field8.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepStruct) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepStruct) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidEmbeddedStruct) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + n += 3 + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinEmbeddedStruct) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field200 != nil { + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.Field210 != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidNestedStruct) Size() (n int) { + var l int + _ = l + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + if len(m.Field2) > 0 { + for _, e := range m.Field2 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinNestedStruct) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.Field2) > 0 { + for _, e := range m.Field2 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptCustom) Size() (n int) { + var l int + _ = l + l = m.Id.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomDash) Size() (n int) { + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptCustom) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepCustom) Size() (n int) { + var l int + _ = l + if len(m.Id) > 0 { + for _, e := range m.Id { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Value) > 0 { + for _, e := range m.Value { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepCustom) Size() (n int) { + var l int + _ = l + if len(m.Id) > 0 { + for _, e := range m.Id { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Value) > 0 { + for _, e := range m.Value { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNativeUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptStructUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field4 != nil { + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinEmbeddedStructUnion) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field200 != nil { + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.Field210 != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinNestedStructUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field2 != nil { + l = m.Field2.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Tree) Size() (n int) { + var l int + _ = l + if m.Or != nil { + l = m.Or.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.And != nil { + l = m.And.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Leaf != nil { + l = m.Leaf.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *OrBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AndBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Leaf) Size() (n int) { + var l int + _ = l + n += 1 + sovThetest(uint64(m.Value)) + l = len(m.StrValue) + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DeepTree) Size() (n int) { + var l int + _ = l + if m.Down != nil { + l = m.Down.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.And != nil { + l = m.And.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Leaf != nil { + l = m.Leaf.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ADeepBranch) Size() (n int) { + var l int + _ = l + l = m.Down.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AndDeepBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DeepLeaf) Size() (n int) { + var l int + _ = l + l = m.Tree.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Nil) Size() (n int) { + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptEnum) Size() (n int) { + var l int + _ = l + n += 1 + sovThetest(uint64(m.Field1)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptEnum) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepEnum) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + for _, e := range m.Field1 { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepEnum) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + for _, e := range m.Field1 { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptEnumDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AnotherNinOptEnum) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AnotherNinOptEnumDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Timer) Size() (n int) { + var l int + _ = l + n += 9 + n += 9 + if m.Data != nil { + l = len(m.Data) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *MyExtendable) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + n += github_com_gogo_protobuf_proto.SizeOfExtensionMap(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *OtherExtenable) Size() (n int) { + var l int + _ = l + if m.Field2 != nil { + n += 1 + sovThetest(uint64(*m.Field2)) + } + if m.Field13 != nil { + n += 1 + sovThetest(uint64(*m.Field13)) + } + if m.M != nil { + l = m.M.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_extensions != nil { + n += github_com_gogo_protobuf_proto.SizeOfExtensionMap(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.EnumField != nil { + n += 1 + sovThetest(uint64(*m.EnumField)) + } + if m.NNM != nil { + l = m.NNM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.NM != nil { + l = m.NM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition_NestedMessage) Size() (n int) { + var l int + _ = l + if m.NestedField1 != nil { + n += 9 + } + if m.NNM != nil { + l = m.NNM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Size() (n int) { + var l int + _ = l + if m.NestedNestedField1 != nil { + l = len(*m.NestedNestedField1) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedScope) Size() (n int) { + var l int + _ = l + if m.A != nil { + l = m.A.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.B != nil { + n += 1 + sovThetest(uint64(*m.B)) + } + if m.C != nil { + l = m.C.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNativeDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + n += 1 + sozThetest(uint64(*m.Field8)) + } + if m.Field9 != nil { + n += 5 + } + if m.Field10 != nil { + n += 5 + } + if m.Field11 != nil { + n += 9 + } + if m.Field12 != nil { + n += 9 + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomContainer) Size() (n int) { + var l int + _ = l + l = m.CustomStruct.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNidOptNative) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + n += 1 + sovThetest(uint64(m.FieldC)) + n += 1 + sovThetest(uint64(m.FieldD)) + n += 1 + sovThetest(uint64(m.FieldE)) + n += 1 + sovThetest(uint64(m.FieldF)) + n += 1 + sozThetest(uint64(m.FieldG)) + n += 1 + sozThetest(uint64(m.FieldH)) + n += 5 + n += 5 + n += 9 + n += 9 + n += 2 + l = len(m.FieldN) + n += 1 + l + sovThetest(uint64(l)) + if m.FieldO != nil { + l = len(m.FieldO) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinOptNative) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 9 + } + if m.FieldB != nil { + n += 5 + } + if m.FieldC != nil { + n += 1 + sovThetest(uint64(*m.FieldC)) + } + if m.FieldD != nil { + n += 1 + sovThetest(uint64(*m.FieldD)) + } + if m.FieldE != nil { + n += 1 + sovThetest(uint64(*m.FieldE)) + } + if m.FieldF != nil { + n += 1 + sovThetest(uint64(*m.FieldF)) + } + if m.FieldG != nil { + n += 1 + sozThetest(uint64(*m.FieldG)) + } + if m.FieldH != nil { + n += 1 + sozThetest(uint64(*m.FieldH)) + } + if m.FieldI != nil { + n += 5 + } + if m.FieldJ != nil { + n += 5 + } + if m.FieldK != nil { + n += 9 + } + if m.FielL != nil { + n += 9 + } + if m.FieldM != nil { + n += 2 + } + if m.FieldN != nil { + l = len(*m.FieldN) + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldO != nil { + l = len(m.FieldO) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinRepNative) Size() (n int) { + var l int + _ = l + if len(m.FieldA) > 0 { + n += 9 * len(m.FieldA) + } + if len(m.FieldB) > 0 { + n += 5 * len(m.FieldB) + } + if len(m.FieldC) > 0 { + for _, e := range m.FieldC { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldE) > 0 { + for _, e := range m.FieldE { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldF) > 0 { + for _, e := range m.FieldF { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldG) > 0 { + for _, e := range m.FieldG { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.FieldH) > 0 { + for _, e := range m.FieldH { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.FieldI) > 0 { + n += 5 * len(m.FieldI) + } + if len(m.FieldJ) > 0 { + n += 5 * len(m.FieldJ) + } + if len(m.FieldK) > 0 { + n += 9 * len(m.FieldK) + } + if len(m.FieldL) > 0 { + n += 9 * len(m.FieldL) + } + if len(m.FieldM) > 0 { + n += 2 * len(m.FieldM) + } + if len(m.FieldN) > 0 { + for _, s := range m.FieldN { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.FieldO) > 0 { + for _, b := range m.FieldO { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinStruct) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 9 + } + if m.FieldB != nil { + n += 5 + } + if m.FieldC != nil { + l = m.FieldC.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.FieldE != nil { + n += 1 + sovThetest(uint64(*m.FieldE)) + } + if m.FieldF != nil { + n += 1 + sozThetest(uint64(*m.FieldF)) + } + if m.FieldG != nil { + l = m.FieldG.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldH != nil { + n += 2 + } + if m.FieldI != nil { + l = len(*m.FieldI) + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldJ != nil { + l = len(m.FieldJ) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameCustomType) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + l = m.FieldA.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldB != nil { + l = m.FieldB.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.FieldC) > 0 { + for _, e := range m.FieldC { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinEmbeddedStructUnion) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldA != nil { + l = m.FieldA.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.FieldB != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameEnum) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 1 + sovThetest(uint64(*m.FieldA)) + } + if len(m.FieldB) > 0 { + for _, e := range m.FieldB { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NoExtensionsMap) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + n += len(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Unrecognized) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = len(*m.Field1) + n += 1 + l + sovThetest(uint64(l)) + } + return n +} + +func (m *UnrecognizedWithInner) Size() (n int) { + var l int + _ = l + if len(m.Embedded) > 0 { + for _, e := range m.Embedded { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.Field2 != nil { + l = len(*m.Field2) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UnrecognizedWithInner_Inner) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + return n +} + +func (m *UnrecognizedWithEmbed) Size() (n int) { + var l int + _ = l + l = m.UnrecognizedWithEmbed_Embedded.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.Field2 != nil { + l = len(*m.Field2) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UnrecognizedWithEmbed_Embedded) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + return n +} + +func sovThetest(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozThetest(x uint64) (n int) { + return sovThetest(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *NidOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNative{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + valueToStringThetest(this.Field8) + `,`, + `Field9:` + valueToStringThetest(this.Field9) + `,`, + `Field10:` + valueToStringThetest(this.Field10) + `,`, + `Field11:` + valueToStringThetest(this.Field11) + `,`, + `Field12:` + valueToStringThetest(this.Field12) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepPackedNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepPackedNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepPackedNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepPackedNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(strings.Replace(this.Field3.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field4:` + strings.Replace(strings.Replace(this.Field4.String(), "NinOptNative", "NinOptNative", 1), `&`, ``, 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(strings.Replace(this.Field8.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptStruct{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field4:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1), `&`, ``, 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidEmbeddedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidEmbeddedStruct{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(strings.Replace(this.Field200.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field210:` + fmt.Sprintf("%v", this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinEmbeddedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinEmbeddedStruct{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(fmt.Sprintf("%v", this.Field200), "NidOptNative", "NidOptNative", 1) + `,`, + `Field210:` + valueToStringThetest(this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidNestedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidNestedStruct{`, + `Field1:` + strings.Replace(strings.Replace(this.Field1.String(), "NidOptStruct", "NidOptStruct", 1), `&`, ``, 1) + `,`, + `Field2:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field2), "NidRepStruct", "NidRepStruct", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinNestedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinNestedStruct{`, + `Field1:` + strings.Replace(fmt.Sprintf("%v", this.Field1), "NinOptStruct", "NinOptStruct", 1) + `,`, + `Field2:` + strings.Replace(fmt.Sprintf("%v", this.Field2), "NinRepStruct", "NinRepStruct", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomDash) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomDash{`, + `Value:` + valueToStringThetest(this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptCustom{`, + `Id:` + valueToStringThetest(this.Id) + `,`, + `Value:` + valueToStringThetest(this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNativeUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNativeUnion{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptStructUnion{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinEmbeddedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinEmbeddedStructUnion{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(fmt.Sprintf("%v", this.Field200), "NinOptNative", "NinOptNative", 1) + `,`, + `Field210:` + valueToStringThetest(this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinNestedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinNestedStructUnion{`, + `Field1:` + strings.Replace(fmt.Sprintf("%v", this.Field1), "NinOptNativeUnion", "NinOptNativeUnion", 1) + `,`, + `Field2:` + strings.Replace(fmt.Sprintf("%v", this.Field2), "NinOptStructUnion", "NinOptStructUnion", 1) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NinEmbeddedStructUnion", "NinEmbeddedStructUnion", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Tree) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Tree{`, + `Or:` + strings.Replace(fmt.Sprintf("%v", this.Or), "OrBranch", "OrBranch", 1) + `,`, + `And:` + strings.Replace(fmt.Sprintf("%v", this.And), "AndBranch", "AndBranch", 1) + `,`, + `Leaf:` + strings.Replace(fmt.Sprintf("%v", this.Leaf), "Leaf", "Leaf", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OrBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OrBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AndBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AndBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Leaf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Leaf{`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `StrValue:` + fmt.Sprintf("%v", this.StrValue) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *DeepTree) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DeepTree{`, + `Down:` + strings.Replace(fmt.Sprintf("%v", this.Down), "ADeepBranch", "ADeepBranch", 1) + `,`, + `And:` + strings.Replace(fmt.Sprintf("%v", this.And), "AndDeepBranch", "AndDeepBranch", 1) + `,`, + `Leaf:` + strings.Replace(fmt.Sprintf("%v", this.Leaf), "DeepLeaf", "DeepLeaf", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ADeepBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ADeepBranch{`, + `Down:` + strings.Replace(strings.Replace(this.Down.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AndDeepBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AndDeepBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *DeepLeaf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DeepLeaf{`, + `Tree:` + strings.Replace(strings.Replace(this.Tree.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Nil) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Nil{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptEnum{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptEnumDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptEnumDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AnotherNinOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnotherNinOptEnum{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AnotherNinOptEnumDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnotherNinOptEnumDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Timer) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Timer{`, + `Time1:` + fmt.Sprintf("%v", this.Time1) + `,`, + `Time2:` + fmt.Sprintf("%v", this.Time2) + `,`, + `Data:` + fmt.Sprintf("%v", this.Data) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *MyExtendable) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&MyExtendable{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsMap(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OtherExtenable) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OtherExtenable{`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `M:` + strings.Replace(fmt.Sprintf("%v", this.M), "MyExtendable", "MyExtendable", 1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsMap(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `EnumField:` + valueToStringThetest(this.EnumField) + `,`, + `NNM:` + strings.Replace(fmt.Sprintf("%v", this.NNM), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `NM:` + strings.Replace(fmt.Sprintf("%v", this.NM), "NestedDefinition_NestedMessage", "NestedDefinition_NestedMessage", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition_NestedMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition_NestedMessage{`, + `NestedField1:` + valueToStringThetest(this.NestedField1) + `,`, + `NNM:` + strings.Replace(fmt.Sprintf("%v", this.NNM), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition_NestedMessage_NestedNestedMsg{`, + `NestedNestedField1:` + valueToStringThetest(this.NestedNestedField1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedScope) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedScope{`, + `A:` + strings.Replace(fmt.Sprintf("%v", this.A), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `B:` + valueToStringThetest(this.B) + `,`, + `C:` + strings.Replace(fmt.Sprintf("%v", this.C), "NestedDefinition_NestedMessage", "NestedDefinition_NestedMessage", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNativeDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNativeDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + valueToStringThetest(this.Field8) + `,`, + `Field9:` + valueToStringThetest(this.Field9) + `,`, + `Field10:` + valueToStringThetest(this.Field10) + `,`, + `Field11:` + valueToStringThetest(this.Field11) + `,`, + `Field12:` + valueToStringThetest(this.Field12) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomContainer) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomContainer{`, + `CustomStruct:` + strings.Replace(strings.Replace(this.CustomStruct.String(), "NidOptCustom", "NidOptCustom", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNidOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNidOptNative{`, + `FieldA:` + fmt.Sprintf("%v", this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `FieldE:` + fmt.Sprintf("%v", this.FieldE) + `,`, + `FieldF:` + fmt.Sprintf("%v", this.FieldF) + `,`, + `FieldG:` + fmt.Sprintf("%v", this.FieldG) + `,`, + `FieldH:` + fmt.Sprintf("%v", this.FieldH) + `,`, + `FieldI:` + fmt.Sprintf("%v", this.FieldI) + `,`, + `FieldJ:` + fmt.Sprintf("%v", this.FieldJ) + `,`, + `FieldK:` + fmt.Sprintf("%v", this.FieldK) + `,`, + `FieldL:` + fmt.Sprintf("%v", this.FieldL) + `,`, + `FieldM:` + fmt.Sprintf("%v", this.FieldM) + `,`, + `FieldN:` + fmt.Sprintf("%v", this.FieldN) + `,`, + `FieldO:` + fmt.Sprintf("%v", this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinOptNative{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + valueToStringThetest(this.FieldC) + `,`, + `FieldD:` + valueToStringThetest(this.FieldD) + `,`, + `FieldE:` + valueToStringThetest(this.FieldE) + `,`, + `FieldF:` + valueToStringThetest(this.FieldF) + `,`, + `FieldG:` + valueToStringThetest(this.FieldG) + `,`, + `FieldH:` + valueToStringThetest(this.FieldH) + `,`, + `FieldI:` + valueToStringThetest(this.FieldI) + `,`, + `FieldJ:` + valueToStringThetest(this.FieldJ) + `,`, + `FieldK:` + valueToStringThetest(this.FieldK) + `,`, + `FielL:` + valueToStringThetest(this.FielL) + `,`, + `FieldM:` + valueToStringThetest(this.FieldM) + `,`, + `FieldN:` + valueToStringThetest(this.FieldN) + `,`, + `FieldO:` + valueToStringThetest(this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinRepNative{`, + `FieldA:` + fmt.Sprintf("%v", this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `FieldE:` + fmt.Sprintf("%v", this.FieldE) + `,`, + `FieldF:` + fmt.Sprintf("%v", this.FieldF) + `,`, + `FieldG:` + fmt.Sprintf("%v", this.FieldG) + `,`, + `FieldH:` + fmt.Sprintf("%v", this.FieldH) + `,`, + `FieldI:` + fmt.Sprintf("%v", this.FieldI) + `,`, + `FieldJ:` + fmt.Sprintf("%v", this.FieldJ) + `,`, + `FieldK:` + fmt.Sprintf("%v", this.FieldK) + `,`, + `FieldL:` + fmt.Sprintf("%v", this.FieldL) + `,`, + `FieldM:` + fmt.Sprintf("%v", this.FieldM) + `,`, + `FieldN:` + fmt.Sprintf("%v", this.FieldN) + `,`, + `FieldO:` + fmt.Sprintf("%v", this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinStruct{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + strings.Replace(fmt.Sprintf("%v", this.FieldC), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldD:` + strings.Replace(fmt.Sprintf("%v", this.FieldD), "NinOptNative", "NinOptNative", 1) + `,`, + `FieldE:` + valueToStringThetest(this.FieldE) + `,`, + `FieldF:` + valueToStringThetest(this.FieldF) + `,`, + `FieldG:` + strings.Replace(fmt.Sprintf("%v", this.FieldG), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldH:` + valueToStringThetest(this.FieldH) + `,`, + `FieldI:` + valueToStringThetest(this.FieldI) + `,`, + `FieldJ:` + valueToStringThetest(this.FieldJ) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameCustomType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameCustomType{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinEmbeddedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinEmbeddedStructUnion{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldA:` + strings.Replace(fmt.Sprintf("%v", this.FieldA), "NinOptNative", "NinOptNative", 1) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameEnum{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NoExtensionsMap) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NoExtensionsMap{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsBytes(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Unrecognized) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Unrecognized{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithInner) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithInner{`, + `Embedded:` + strings.Replace(fmt.Sprintf("%v", this.Embedded), "UnrecognizedWithInner_Inner", "UnrecognizedWithInner_Inner", 1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithInner_Inner) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithInner_Inner{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithEmbed) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithEmbed{`, + `UnrecognizedWithEmbed_Embedded:` + strings.Replace(strings.Replace(this.UnrecognizedWithEmbed_Embedded.String(), "UnrecognizedWithEmbed_Embedded", "UnrecognizedWithEmbed_Embedded", 1), `&`, ``, 1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithEmbed_Embedded) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithEmbed_Embedded{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func valueToStringThetest(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (this *NinOptNativeUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + if this.Field4 != nil { + return this.Field4 + } + if this.Field5 != nil { + return this.Field5 + } + if this.Field6 != nil { + return this.Field6 + } + if this.Field13 != nil { + return this.Field13 + } + if this.Field14 != nil { + return this.Field14 + } + if this.Field15 != nil { + return this.Field15 + } + return nil +} + +func (this *NinOptNativeUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *float64: + this.Field1 = vt + case *float32: + this.Field2 = vt + case *int32: + this.Field3 = vt + case *int64: + this.Field4 = vt + case *uint32: + this.Field5 = vt + case *uint64: + this.Field6 = vt + case *bool: + this.Field13 = vt + case *string: + this.Field14 = vt + case []byte: + this.Field15 = vt + default: + return false + } + return true +} +func (this *NinOptStructUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + if this.Field4 != nil { + return this.Field4 + } + if this.Field6 != nil { + return this.Field6 + } + if this.Field7 != nil { + return this.Field7 + } + if this.Field13 != nil { + return this.Field13 + } + if this.Field14 != nil { + return this.Field14 + } + if this.Field15 != nil { + return this.Field15 + } + return nil +} + +func (this *NinOptStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *float64: + this.Field1 = vt + case *float32: + this.Field2 = vt + case *NidOptNative: + this.Field3 = vt + case *NinOptNative: + this.Field4 = vt + case *uint64: + this.Field6 = vt + case *int32: + this.Field7 = vt + case *bool: + this.Field13 = vt + case *string: + this.Field14 = vt + case []byte: + this.Field15 = vt + default: + return false + } + return true +} +func (this *NinEmbeddedStructUnion) GetValue() interface{} { + if this.NidOptNative != nil { + return this.NidOptNative + } + if this.Field200 != nil { + return this.Field200 + } + if this.Field210 != nil { + return this.Field210 + } + return nil +} + +func (this *NinEmbeddedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NidOptNative: + this.NidOptNative = vt + case *NinOptNative: + this.Field200 = vt + case *bool: + this.Field210 = vt + default: + return false + } + return true +} +func (this *NinNestedStructUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + return nil +} + +func (this *NinNestedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NinOptNativeUnion: + this.Field1 = vt + case *NinOptStructUnion: + this.Field2 = vt + case *NinEmbeddedStructUnion: + this.Field3 = vt + default: + this.Field1 = new(NinOptNativeUnion) + if set := this.Field1.SetValue(value); set { + return true + } + this.Field1 = nil + this.Field2 = new(NinOptStructUnion) + if set := this.Field2.SetValue(value); set { + return true + } + this.Field2 = nil + this.Field3 = new(NinEmbeddedStructUnion) + if set := this.Field3.SetValue(value); set { + return true + } + this.Field3 = nil + return false + } + return true +} +func (this *Tree) GetValue() interface{} { + if this.Or != nil { + return this.Or + } + if this.And != nil { + return this.And + } + if this.Leaf != nil { + return this.Leaf + } + return nil +} + +func (this *Tree) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *OrBranch: + this.Or = vt + case *AndBranch: + this.And = vt + case *Leaf: + this.Leaf = vt + default: + return false + } + return true +} +func (this *DeepTree) GetValue() interface{} { + if this.Down != nil { + return this.Down + } + if this.And != nil { + return this.And + } + if this.Leaf != nil { + return this.Leaf + } + return nil +} + +func (this *DeepTree) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *ADeepBranch: + this.Down = vt + case *AndDeepBranch: + this.And = vt + case *DeepLeaf: + this.Leaf = vt + default: + return false + } + return true +} +func (this *CustomNameNinEmbeddedStructUnion) GetValue() interface{} { + if this.NidOptNative != nil { + return this.NidOptNative + } + if this.FieldA != nil { + return this.FieldA + } + if this.FieldB != nil { + return this.FieldB + } + return nil +} + +func (this *CustomNameNinEmbeddedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NidOptNative: + this.NidOptNative = vt + case *NinOptNative: + this.FieldA = vt + case *bool: + this.FieldB = vt + default: + return false + } + return true +} +func (m *NidOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.Field1 = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + m.Field2 = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + m.Field3 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field3 |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + m.Field4 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field4 |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + m.Field5 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field5 |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + m.Field6 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field6 |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = int64(v) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + m.Field9 = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + m.Field10 = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.Field11 = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.Field12 = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = bool(v != 0) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = &v + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = &v + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = &v + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + v2 := int64(v) + m.Field8 = &v2 + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = &v + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = &v + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = &v + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = append(m.Field9, v) + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = append(m.Field10, v) + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = append(m.Field11, v) + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = append(m.Field12, v) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = append(m.Field14, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx)) + copy(m.Field15[len(m.Field15)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = append(m.Field9, v) + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = append(m.Field10, v) + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = append(m.Field11, v) + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = append(m.Field12, v) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = append(m.Field14, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx)) + copy(m.Field15[len(m.Field15)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepPackedNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepPackedNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepPackedNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + } + } else if wireType == 1 { + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + case 2: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + } + } else if wireType == 5 { + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + case 3: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + case 4: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } + } else if wireType == 0 { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + case 5: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } + } else if wireType == 0 { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + case 6: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + case 7: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + case 8: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + case 9: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = append(m.Field9, v) + } + } else if wireType == 5 { + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = append(m.Field9, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + case 10: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = append(m.Field10, v) + } + } else if wireType == 5 { + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = append(m.Field10, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + case 11: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = append(m.Field11, v) + } + } else if wireType == 1 { + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = append(m.Field11, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + case 12: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = append(m.Field12, v) + } + } else if wireType == 1 { + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = append(m.Field12, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + case 13: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } + } else if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepPackedNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepPackedNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepPackedNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + } + } else if wireType == 1 { + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + case 2: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + } + } else if wireType == 5 { + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + case 3: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + case 4: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } + } else if wireType == 0 { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + case 5: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } + } else if wireType == 0 { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + case 6: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + case 7: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + case 8: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + case 9: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = append(m.Field9, v) + } + } else if wireType == 5 { + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = append(m.Field9, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + case 10: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = append(m.Field10, v) + } + } else if wireType == 5 { + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = append(m.Field10, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + case 11: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = append(m.Field11, v) + } + } else if wireType == 1 { + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = append(m.Field11, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + case 12: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = append(m.Field12, v) + } + } else if wireType == 1 { + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = append(m.Field12, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + case 13: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } + } else if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidOptStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidOptStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidOptStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.Field1 = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + m.Field2 = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field4.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + m.Field6 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field6 |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = v + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field8.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = bool(v != 0) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = &v + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = &v + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field3 == nil { + m.Field3 = &NidOptNative{} + } + if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field4 == nil { + m.Field4 = &NinOptNative{} + } + if err := m.Field4.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field8 == nil { + m.Field8 = &NidOptNative{} + } + if err := m.Field8.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field3 = append(m.Field3, NidOptNative{}) + if err := m.Field3[len(m.Field3)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field4 = append(m.Field4, NinOptNative{}) + if err := m.Field4[len(m.Field4)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field8 = append(m.Field8, NidOptNative{}) + if err := m.Field8[len(m.Field8)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = append(m.Field14, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx)) + copy(m.Field15[len(m.Field15)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field3 = append(m.Field3, &NidOptNative{}) + if err := m.Field3[len(m.Field3)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field4 = append(m.Field4, &NinOptNative{}) + if err := m.Field4[len(m.Field4)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field8 = append(m.Field8, &NidOptNative{}) + if err := m.Field8[len(m.Field8)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = append(m.Field14, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append(m.Field15, make([]byte, postIndex-iNdEx)) + copy(m.Field15[len(m.Field15)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidEmbeddedStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidEmbeddedStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidEmbeddedStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NidOptNative == nil { + m.NidOptNative = &NidOptNative{} + } + if err := m.NidOptNative.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field200", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field200.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 210: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field210", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field210 = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinEmbeddedStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinEmbeddedStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinEmbeddedStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NidOptNative == nil { + m.NidOptNative = &NidOptNative{} + } + if err := m.NidOptNative.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field200", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field200 == nil { + m.Field200 = &NidOptNative{} + } + if err := m.Field200.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 210: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field210", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field210 = &b + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidNestedStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidNestedStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidNestedStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Field1.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field2 = append(m.Field2, NidRepStruct{}) + if err := m.Field2[len(m.Field2)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinNestedStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinNestedStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinNestedStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field1 == nil { + m.Field1 = &NinOptStruct{} + } + if err := m.Field1.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field2 = append(m.Field2, &NinRepStruct{}) + if err := m.Field2[len(m.Field2)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidOptCustom) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidOptCustom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidOptCustom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Id.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Value.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomDash) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomDash: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomDash: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom_dash_type.Bytes + m.Value = &v + if err := m.Value.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptCustom) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptCustom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptCustom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.Id = &v + if err := m.Id.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.Value = &v + if err := m.Value.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepCustom) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepCustom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepCustom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.Id = append(m.Id, v) + if err := m.Id[len(m.Id)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.Value = append(m.Value, v) + if err := m.Value[len(m.Value)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepCustom) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepCustom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepCustom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.Id = append(m.Id, v) + if err := m.Id[len(m.Id)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.Value = append(m.Value, v) + if err := m.Value[len(m.Value)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptNativeUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptNativeUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptNativeUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = &v + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = &v + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = &v + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptStructUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptStructUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptStructUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = &v + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = &v + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field3 == nil { + m.Field3 = &NidOptNative{} + } + if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field4 == nil { + m.Field4 = &NinOptNative{} + } + if err := m.Field4.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinEmbeddedStructUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinEmbeddedStructUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinEmbeddedStructUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NidOptNative == nil { + m.NidOptNative = &NidOptNative{} + } + if err := m.NidOptNative.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field200", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field200 == nil { + m.Field200 = &NinOptNative{} + } + if err := m.Field200.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 210: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field210", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field210 = &b + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinNestedStructUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinNestedStructUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinNestedStructUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field1 == nil { + m.Field1 = &NinOptNativeUnion{} + } + if err := m.Field1.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field2 == nil { + m.Field2 = &NinOptStructUnion{} + } + if err := m.Field2.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field3 == nil { + m.Field3 = &NinEmbeddedStructUnion{} + } + if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Tree) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Tree: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Tree: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Or", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Or == nil { + m.Or = &OrBranch{} + } + if err := m.Or.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field And", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.And == nil { + m.And = &AndBranch{} + } + if err := m.And.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Leaf", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Leaf == nil { + m.Leaf = &Leaf{} + } + if err := m.Leaf.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OrBranch) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OrBranch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OrBranch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Left.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Right.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AndBranch) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AndBranch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AndBranch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Left.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Right.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Leaf) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Leaf: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Leaf: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + m.Value = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Value |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StrValue", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StrValue = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DeepTree) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DeepTree: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeepTree: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Down", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Down == nil { + m.Down = &ADeepBranch{} + } + if err := m.Down.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field And", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.And == nil { + m.And = &AndDeepBranch{} + } + if err := m.And.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Leaf", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Leaf == nil { + m.Leaf = &DeepLeaf{} + } + if err := m.Leaf.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ADeepBranch) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ADeepBranch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ADeepBranch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Down", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Down.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AndDeepBranch) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AndDeepBranch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AndDeepBranch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Left.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Right.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DeepLeaf) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DeepLeaf: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeepLeaf: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tree", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Tree.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Nil) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Nil: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Nil: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidOptEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidOptEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidOptEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + m.Field1 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field1 |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidRepEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidRepEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidRepEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = append(m.Field1, v) + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = append(m.Field1, v) + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptEnumDefault) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptEnumDefault: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptEnumDefault: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnotherNinOptEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnotherNinOptEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnotherNinOptEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v AnotherTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (AnotherTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AnotherNinOptEnumDefault) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AnotherNinOptEnumDefault: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AnotherNinOptEnumDefault: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v AnotherTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (AnotherTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Timer) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Timer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Timer: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Time1", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.Time1 = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 2: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Time2", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.Time2 = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MyExtendable) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MyExtendable: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MyExtendable: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + if (fieldNum >= 100) && (fieldNum < 200) { + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + iNdEx -= sizeOfWire + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]github_com_gogo_protobuf_proto.Extension) + } + m.XXX_extensions[int32(fieldNum)] = github_com_gogo_protobuf_proto.NewExtension(data[iNdEx : iNdEx+skippy]) + iNdEx += skippy + } else { + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OtherExtenable) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OtherExtenable: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OtherExtenable: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field2 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = &v + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field M", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.M == nil { + m.M = &MyExtendable{} + } + if err := m.M.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + if ((fieldNum >= 14) && (fieldNum < 17)) || ((fieldNum >= 10) && (fieldNum < 13)) { + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + iNdEx -= sizeOfWire + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]github_com_gogo_protobuf_proto.Extension) + } + m.XXX_extensions[int32(fieldNum)] = github_com_gogo_protobuf_proto.NewExtension(data[iNdEx : iNdEx+skippy]) + iNdEx += skippy + } else { + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NestedDefinition) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NestedDefinition: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NestedDefinition: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EnumField", wireType) + } + var v NestedDefinition_NestedEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (NestedDefinition_NestedEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.EnumField = &v + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NNM", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NNM == nil { + m.NNM = &NestedDefinition_NestedMessage_NestedNestedMsg{} + } + if err := m.NNM.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NM", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NM == nil { + m.NM = &NestedDefinition_NestedMessage{} + } + if err := m.NM.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NestedDefinition_NestedMessage) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NestedMessage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NestedMessage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field NestedField1", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.NestedField1 = &v + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NNM", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NNM == nil { + m.NNM = &NestedDefinition_NestedMessage_NestedNestedMsg{} + } + if err := m.NNM.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NestedNestedMsg: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NestedNestedMsg: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NestedNestedField1", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.NestedNestedField1 = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NestedScope) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NestedScope: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NestedScope: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.A == nil { + m.A = &NestedDefinition_NestedMessage_NestedNestedMsg{} + } + if err := m.A.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var v NestedDefinition_NestedEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (NestedDefinition_NestedEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.B = &v + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field C", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.C == nil { + m.C = &NestedDefinition_NestedMessage{} + } + if err := m.C.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptNativeDefault) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptNativeDefault: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptNativeDefault: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = &v + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = &v + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = &v + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + v2 := int64(v) + m.Field8 = &v2 + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = &v + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = &v + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = &v + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomContainer) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomContainer: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomContainer: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CustomStruct", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.CustomStruct.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNidOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNidOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNidOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.FieldA = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + m.FieldB = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + m.FieldC = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.FieldC |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + m.FieldD = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.FieldD |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) + } + m.FieldE = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.FieldE |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) + } + m.FieldF = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.FieldF |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.FieldG = v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.FieldH = int64(v) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType) + } + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + m.FieldI = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType) + } + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + m.FieldJ = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldK", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.FieldK = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldL", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.FieldL = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldM", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldM = bool(v != 0) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldN", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldN = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldO", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldO = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNinOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNinOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNinOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.FieldA = &v + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.FieldB = &v + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldC = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldD = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldE = &v + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldF = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.FieldG = &v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + v2 := int64(v) + m.FieldH = &v2 + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType) + } + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.FieldI = &v + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType) + } + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.FieldJ = &v + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldK", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.FieldK = &v + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FielL", wireType) + } + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.FielL = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldM", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.FieldM = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldN", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.FieldN = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldO", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldO = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNinRepNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNinRepNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNinRepNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.FieldA = append(m.FieldA, v) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.FieldB = append(m.FieldB, v) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldC = append(m.FieldC, v) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldD = append(m.FieldD, v) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldE = append(m.FieldE, v) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldF = append(m.FieldF, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.FieldG = append(m.FieldG, v) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.FieldH = append(m.FieldH, int64(v)) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType) + } + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.FieldI = append(m.FieldI, v) + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType) + } + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.FieldJ = append(m.FieldJ, v) + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldK", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.FieldK = append(m.FieldK, v) + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldL", wireType) + } + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.FieldL = append(m.FieldL, v) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldM", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldM = append(m.FieldM, bool(v != 0)) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldN", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldN = append(m.FieldN, string(data[iNdEx:postIndex])) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldO", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldO = append(m.FieldO, make([]byte, postIndex-iNdEx)) + copy(m.FieldO[len(m.FieldO)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNinStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNinStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNinStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.FieldA = &v + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.FieldB = &v + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FieldC == nil { + m.FieldC = &NidOptNative{} + } + if err := m.FieldC.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldD = append(m.FieldD, &NinOptNative{}) + if err := m.FieldD[len(m.FieldD)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldE", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldE = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldF", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.FieldF = &v + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldG", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FieldG == nil { + m.FieldG = &NidOptNative{} + } + if err := m.FieldG.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldH", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.FieldH = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldI", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.FieldI = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldJ", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FieldJ = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameCustomType) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameCustomType: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameCustomType: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.FieldA = &v + if err := m.FieldA.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.FieldB = &v + if err := m.FieldB.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldC", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v Uuid + m.FieldC = append(m.FieldC, v) + if err := m.FieldC[len(m.FieldC)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldD", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.FieldD = append(m.FieldD, v) + if err := m.FieldD[len(m.FieldD)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameNinEmbeddedStructUnion) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameNinEmbeddedStructUnion: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameNinEmbeddedStructUnion: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NidOptNative", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NidOptNative == nil { + m.NidOptNative = &NidOptNative{} + } + if err := m.NidOptNative.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 200: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.FieldA == nil { + m.FieldA = &NinOptNative{} + } + if err := m.FieldA.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 210: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.FieldB = &b + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomNameEnum) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomNameEnum: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomNameEnum: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldA", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldA = &v + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FieldB", wireType) + } + var v TheTestEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (TheTestEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.FieldB = append(m.FieldB, v) + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NoExtensionsMap) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NoExtensionsMap: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NoExtensionsMap: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + if (fieldNum >= 100) && (fieldNum < 200) { + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + iNdEx -= sizeOfWire + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_extensions = append(m.XXX_extensions, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } else { + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Unrecognized) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Unrecognized: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Unrecognized: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field1 = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnrecognizedWithInner) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UnrecognizedWithInner: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UnrecognizedWithInner: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Embedded", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Embedded = append(m.Embedded, &UnrecognizedWithInner_Inner{}) + if err := m.Embedded[len(m.Embedded)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field2 = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnrecognizedWithInner_Inner) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Inner: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Inner: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnrecognizedWithEmbed) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UnrecognizedWithEmbed: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UnrecognizedWithEmbed: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UnrecognizedWithEmbed_Embedded", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.UnrecognizedWithEmbed_Embedded.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthThetestUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field2 = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UnrecognizedWithEmbed_Embedded) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Embedded: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Embedded: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipThetestUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthThetestUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipThetestUnsafe(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthThetestUnsafe + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowThetestUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipThetestUnsafe(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthThetestUnsafe = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowThetestUnsafe = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeunmarshaler/thetest.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeunmarshaler/thetest.proto new file mode 100644 index 0000000000000000000000000000000000000000..82048fe2dfa157bae5cf29d63405c1bc6eb097cd --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeunmarshaler/thetest.proto @@ -0,0 +1,584 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package test; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = true; + +message NidOptNative { + optional double Field1 = 1 [(gogoproto.nullable) = false]; + optional float Field2 = 2 [(gogoproto.nullable) = false]; + optional int32 Field3 = 3 [(gogoproto.nullable) = false]; + optional int64 Field4 = 4 [(gogoproto.nullable) = false]; + optional uint32 Field5 = 5 [(gogoproto.nullable) = false]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false]; + optional sint64 Field8 = 8 [(gogoproto.nullable) = false]; + optional fixed32 Field9 = 9 [(gogoproto.nullable) = false]; + optional sfixed32 Field10 = 10 [(gogoproto.nullable) = false]; + optional fixed64 Field11 = 11 [(gogoproto.nullable) = false]; + optional sfixed64 Field12 = 12 [(gogoproto.nullable) = false]; + optional bool Field13 = 13 [(gogoproto.nullable) = false]; + optional string Field14 = 14 [(gogoproto.nullable) = false]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinOptNative { + optional double Field1 = 1; + optional float Field2 = 2; + optional int32 Field3 = 3; + optional int64 Field4 = 4; + optional uint32 Field5 = 5; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional sint64 Field8 = 8; + optional fixed32 Field9 = 9; + optional sfixed32 Field10 = 10; + optional fixed64 Field11 = 11; + optional sfixed64 Field12 = 12; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NidRepNative { + repeated double Field1 = 1 [(gogoproto.nullable) = false]; + repeated float Field2 = 2 [(gogoproto.nullable) = false]; + repeated int32 Field3 = 3 [(gogoproto.nullable) = false]; + repeated int64 Field4 = 4 [(gogoproto.nullable) = false]; + repeated uint32 Field5 = 5 [(gogoproto.nullable) = false]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false]; + repeated sint64 Field8 = 8 [(gogoproto.nullable) = false]; + repeated fixed32 Field9 = 9 [(gogoproto.nullable) = false]; + repeated sfixed32 Field10 = 10 [(gogoproto.nullable) = false]; + repeated fixed64 Field11 = 11 [(gogoproto.nullable) = false]; + repeated sfixed64 Field12 = 12 [(gogoproto.nullable) = false]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false]; + repeated string Field14 = 14 [(gogoproto.nullable) = false]; + repeated bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinRepNative { + repeated double Field1 = 1; + repeated float Field2 = 2; + repeated int32 Field3 = 3; + repeated int64 Field4 = 4; + repeated uint32 Field5 = 5; + repeated uint64 Field6 = 6; + repeated sint32 Field7 = 7; + repeated sint64 Field8 = 8; + repeated fixed32 Field9 = 9; + repeated sfixed32 Field10 = 10; + repeated fixed64 Field11 = 11; + repeated sfixed64 Field12 = 12; + repeated bool Field13 = 13; + repeated string Field14 = 14; + repeated bytes Field15 = 15; +} + +message NidRepPackedNative { + repeated double Field1 = 1 [(gogoproto.nullable) = false, packed = true]; + repeated float Field2 = 2 [(gogoproto.nullable) = false, packed = true]; + repeated int32 Field3 = 3 [(gogoproto.nullable) = false, packed = true]; + repeated int64 Field4 = 4 [(gogoproto.nullable) = false, packed = true]; + repeated uint32 Field5 = 5 [(gogoproto.nullable) = false, packed = true]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false, packed = true]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false, packed = true]; + repeated sint64 Field8 = 8 [(gogoproto.nullable) = false, packed = true]; + repeated fixed32 Field9 = 9 [(gogoproto.nullable) = false, packed = true]; + repeated sfixed32 Field10 = 10 [(gogoproto.nullable) = false, packed = true]; + repeated fixed64 Field11 = 11 [(gogoproto.nullable) = false, packed = true]; + repeated sfixed64 Field12 = 12 [(gogoproto.nullable) = false, packed = true]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false, packed = true]; +} + +message NinRepPackedNative { + repeated double Field1 = 1 [packed = true]; + repeated float Field2 = 2 [packed = true]; + repeated int32 Field3 = 3 [packed = true]; + repeated int64 Field4 = 4 [packed = true]; + repeated uint32 Field5 = 5 [packed = true]; + repeated uint64 Field6 = 6 [packed = true]; + repeated sint32 Field7 = 7 [packed = true]; + repeated sint64 Field8 = 8 [packed = true]; + repeated fixed32 Field9 = 9 [packed = true]; + repeated sfixed32 Field10 = 10 [packed = true]; + repeated fixed64 Field11 = 11 [packed = true]; + repeated sfixed64 Field12 = 12 [packed = true]; + repeated bool Field13 = 13 [packed = true]; +} + +message NidOptStruct { + optional double Field1 = 1 [(gogoproto.nullable) = false]; + optional float Field2 = 2 [(gogoproto.nullable) = false]; + optional NidOptNative Field3 = 3 [(gogoproto.nullable) = false]; + optional NinOptNative Field4 = 4 [(gogoproto.nullable) = false]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false]; + optional NidOptNative Field8 = 8 [(gogoproto.nullable) = false]; + optional bool Field13 = 13 [(gogoproto.nullable) = false]; + optional string Field14 = 14 [(gogoproto.nullable) = false]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinOptStruct { + optional double Field1 = 1; + optional float Field2 = 2; + optional NidOptNative Field3 = 3; + optional NinOptNative Field4 = 4; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional NidOptNative Field8 = 8; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NidRepStruct { + repeated double Field1 = 1 [(gogoproto.nullable) = false]; + repeated float Field2 = 2 [(gogoproto.nullable) = false]; + repeated NidOptNative Field3 = 3 [(gogoproto.nullable) = false]; + repeated NinOptNative Field4 = 4 [(gogoproto.nullable) = false]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false]; + repeated NidOptNative Field8 = 8 [(gogoproto.nullable) = false]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false]; + repeated string Field14 = 14 [(gogoproto.nullable) = false]; + repeated bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinRepStruct { + repeated double Field1 = 1; + repeated float Field2 = 2; + repeated NidOptNative Field3 = 3; + repeated NinOptNative Field4 = 4; + repeated uint64 Field6 = 6; + repeated sint32 Field7 = 7; + repeated NidOptNative Field8 = 8; + repeated bool Field13 = 13; + repeated string Field14 = 14; + repeated bytes Field15 = 15; +} + +message NidEmbeddedStruct { + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NidOptNative Field200 = 200 [(gogoproto.nullable) = false]; + optional bool Field210 = 210 [(gogoproto.nullable) = false]; +} + +message NinEmbeddedStruct { + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NidOptNative Field200 = 200; + optional bool Field210 = 210; +} + +message NidNestedStruct { + optional NidOptStruct Field1 = 1 [(gogoproto.nullable) = false]; + repeated NidRepStruct Field2 = 2 [(gogoproto.nullable) = false]; +} + +message NinNestedStruct { + optional NinOptStruct Field1 = 1; + repeated NinRepStruct Field2 = 2; +} + +message NidOptCustom { + optional bytes Id = 1 [(gogoproto.customtype) = "Uuid", (gogoproto.nullable) = false]; + optional bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; +} + +message CustomDash { + optional bytes Value = 1 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom-dash-type.Bytes"]; +} + +message NinOptCustom { + optional bytes Id = 1 [(gogoproto.customtype) = "Uuid"]; + optional bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message NidRepCustom { + repeated bytes Id = 1 [(gogoproto.customtype) = "Uuid", (gogoproto.nullable) = false]; + repeated bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; +} + +message NinRepCustom { + repeated bytes Id = 1 [(gogoproto.customtype) = "Uuid"]; + repeated bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message NinOptNativeUnion { + option (gogoproto.onlyone) = true; + optional double Field1 = 1; + optional float Field2 = 2; + optional int32 Field3 = 3; + optional int64 Field4 = 4; + optional uint32 Field5 = 5; + optional uint64 Field6 = 6; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NinOptStructUnion { + option (gogoproto.onlyone) = true; + optional double Field1 = 1; + optional float Field2 = 2; + optional NidOptNative Field3 = 3; + optional NinOptNative Field4 = 4; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NinEmbeddedStructUnion { + option (gogoproto.onlyone) = true; + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NinOptNative Field200 = 200; + optional bool Field210 = 210; +} + +message NinNestedStructUnion { + option (gogoproto.onlyone) = true; + optional NinOptNativeUnion Field1 = 1; + optional NinOptStructUnion Field2 = 2; + optional NinEmbeddedStructUnion Field3 = 3; +} + +message Tree { + option (gogoproto.onlyone) = true; + optional OrBranch Or = 1; + optional AndBranch And = 2; + optional Leaf Leaf = 3; +} + +message OrBranch { + optional Tree Left = 1 [(gogoproto.nullable) = false]; + optional Tree Right = 2 [(gogoproto.nullable) = false]; +} + +message AndBranch { + optional Tree Left = 1 [(gogoproto.nullable) = false]; + optional Tree Right = 2 [(gogoproto.nullable) = false]; +} + +message Leaf { + optional int64 Value = 1 [(gogoproto.nullable) = false]; + optional string StrValue = 2 [(gogoproto.nullable) = false]; +} + +message DeepTree { + option (gogoproto.onlyone) = true; + optional ADeepBranch Down = 1; + optional AndDeepBranch And = 2; + optional DeepLeaf Leaf = 3; +} + +message ADeepBranch { + optional DeepTree Down = 2 [(gogoproto.nullable) = false]; +} + +message AndDeepBranch { + optional DeepTree Left = 1 [(gogoproto.nullable) = false]; + optional DeepTree Right = 2 [(gogoproto.nullable) = false]; +} + +message DeepLeaf { + optional Tree Tree = 1 [(gogoproto.nullable) = false]; +} + +message Nil { + +} + +enum TheTestEnum { + A = 0; + B = 1; + C = 2; +} + +message NidOptEnum { + optional TheTestEnum Field1 = 1 [(gogoproto.nullable) = false]; +} + +message NinOptEnum { + optional TheTestEnum Field1 = 1; +} + +message NidRepEnum { + repeated TheTestEnum Field1 = 1 [(gogoproto.nullable) = false]; +} + +message NinRepEnum { + repeated TheTestEnum Field1 = 1; +} + +message NinOptEnumDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional TheTestEnum Field1 = 1 [default=C]; +} + +enum AnotherTestEnum { + option (gogoproto.goproto_enum_prefix) = false; + D = 10; + E = 11; +} + +message AnotherNinOptEnum { + optional AnotherTestEnum Field1 = 1; +} + +message AnotherNinOptEnumDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional AnotherTestEnum Field1 = 1 [default=E]; +} + +message Timer { + optional sfixed64 Time1 = 1 [(gogoproto.nullable) = false]; + optional sfixed64 Time2 = 2 [(gogoproto.nullable) = false]; + optional bytes Data = 3 [(gogoproto.nullable) = false]; +} + +message MyExtendable { + option (gogoproto.face) = false; + optional int64 Field1 = 1; + extensions 100 to 199; +} + +extend MyExtendable { + optional double FieldA = 100; + optional NinOptNative FieldB = 101; + optional NinEmbeddedStruct FieldC = 102; +} + +message OtherExtenable { + option (gogoproto.face) = false; + optional int64 Field2 = 2; + extensions 14 to 16; + optional int64 Field13 = 13; + extensions 10 to 12; + optional MyExtendable M = 1; +} + +message NestedDefinition { + optional int64 Field1 = 1; + message NestedMessage { + optional fixed64 NestedField1 = 1; + optional NestedNestedMsg NNM = 2; + message NestedNestedMsg { + optional string NestedNestedField1 = 10; + } + } + enum NestedEnum { + TYPE_NESTED = 1; + } + optional NestedEnum EnumField = 2; + optional NestedMessage.NestedNestedMsg NNM = 3; + optional NestedMessage NM = 4; +} + +message NestedScope { + optional NestedDefinition.NestedMessage.NestedNestedMsg A = 1; + optional NestedDefinition.NestedEnum B = 2; + optional NestedDefinition.NestedMessage C = 3; +} + +message NinOptNativeDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional double Field1 = 1 [default = 1234.1234]; + optional float Field2 = 2 [default = 1234.1234]; + optional int32 Field3 = 3 [default = 1234]; + optional int64 Field4 = 4 [default = 1234]; + optional uint32 Field5 = 5 [default = 1234]; + optional uint64 Field6 = 6 [default = 1234]; + optional sint32 Field7 = 7 [default = 1234]; + optional sint64 Field8 = 8 [default = 1234]; + optional fixed32 Field9 = 9 [default = 1234]; + optional sfixed32 Field10 = 10 [default = 1234]; + optional fixed64 Field11 = 11 [default = 1234]; + optional sfixed64 Field12 = 12 [default = 1234]; + optional bool Field13 = 13 [default = true]; + optional string Field14 = 14 [default = "1234"]; + optional bytes Field15 = 15; +} + +message CustomContainer { + optional NidOptCustom CustomStruct = 1 [(gogoproto.nullable) = false]; +} + +message CustomNameNidOptNative { + optional double Field1 = 1 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldB"]; + optional int32 Field3 = 3 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldC"]; + optional int64 Field4 = 4 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldD"]; + optional uint32 Field5 = 5 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldE"]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldF"]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldG"]; + optional sint64 Field8 = 8 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldH"]; + optional fixed32 Field9 = 9 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldI"]; + optional sfixed32 Field10 = 10 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldJ"]; + optional fixed64 Field11 = 11 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldK"]; + optional sfixed64 Field12 = 12 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldL"]; + optional bool Field13 = 13 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldM"]; + optional string Field14 = 14 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldN"]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinOptNative { + optional double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + optional int32 Field3 = 3 [(gogoproto.customname) = "FieldC"]; + optional int64 Field4 = 4 [(gogoproto.customname) = "FieldD"]; + optional uint32 Field5 = 5 [(gogoproto.customname) = "FieldE"]; + optional uint64 Field6 = 6 [(gogoproto.customname) = "FieldF"]; + optional sint32 Field7 = 7 [(gogoproto.customname) = "FieldG"]; + optional sint64 Field8 = 8 [(gogoproto.customname) = "FieldH"]; + optional fixed32 Field9 = 9 [(gogoproto.customname) = "FieldI"]; + optional sfixed32 Field10 = 10 [(gogoproto.customname) = "FieldJ"]; + optional fixed64 Field11 = 11 [(gogoproto.customname) = "FieldK"]; + optional sfixed64 Field12 = 12 [(gogoproto.customname) = "FielL"]; + optional bool Field13 = 13 [(gogoproto.customname) = "FieldM"]; + optional string Field14 = 14 [(gogoproto.customname) = "FieldN"]; + optional bytes Field15 = 15 [(gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinRepNative { + repeated double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + repeated float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + repeated int32 Field3 = 3 [(gogoproto.customname) = "FieldC"]; + repeated int64 Field4 = 4 [(gogoproto.customname) = "FieldD"]; + repeated uint32 Field5 = 5 [(gogoproto.customname) = "FieldE"]; + repeated uint64 Field6 = 6 [(gogoproto.customname) = "FieldF"]; + repeated sint32 Field7 = 7 [(gogoproto.customname) = "FieldG"]; + repeated sint64 Field8 = 8 [(gogoproto.customname) = "FieldH"]; + repeated fixed32 Field9 = 9 [(gogoproto.customname) = "FieldI"]; + repeated sfixed32 Field10 = 10 [(gogoproto.customname) = "FieldJ"]; + repeated fixed64 Field11 = 11 [(gogoproto.customname) = "FieldK"]; + repeated sfixed64 Field12 = 12 [(gogoproto.customname) = "FieldL"]; + repeated bool Field13 = 13 [(gogoproto.customname) = "FieldM"]; + repeated string Field14 = 14 [(gogoproto.customname) = "FieldN"]; + repeated bytes Field15 = 15 [(gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinStruct { + optional double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + optional NidOptNative Field3 = 3 [(gogoproto.customname) = "FieldC"]; + repeated NinOptNative Field4 = 4 [(gogoproto.customname) = "FieldD"]; + optional uint64 Field6 = 6 [(gogoproto.customname) = "FieldE"]; + optional sint32 Field7 = 7 [(gogoproto.customname) = "FieldF"]; + optional NidOptNative Field8 = 8 [(gogoproto.customname) = "FieldG"]; + optional bool Field13 = 13 [(gogoproto.customname) = "FieldH"]; + optional string Field14 = 14 [(gogoproto.customname) = "FieldI"]; + optional bytes Field15 = 15 [(gogoproto.customname) = "FieldJ"]; +} + +message CustomNameCustomType { + optional bytes Id = 1 [(gogoproto.customname) = "FieldA", (gogoproto.customtype) = "Uuid"]; + optional bytes Value = 2 [(gogoproto.customname) = "FieldB", (gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; + repeated bytes Ids = 3 [(gogoproto.customname) = "FieldC", (gogoproto.customtype) = "Uuid"]; + repeated bytes Values = 4 [(gogoproto.customname) = "FieldD", (gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message CustomNameNinEmbeddedStructUnion { + option (gogoproto.onlyone) = true; + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NinOptNative Field200 = 200 [(gogoproto.customname) = "FieldA"]; + optional bool Field210 = 210 [(gogoproto.customname) = "FieldB"]; +} + +message CustomNameEnum { + optional TheTestEnum Field1 = 1 [(gogoproto.customname) = "FieldA"]; + repeated TheTestEnum Field2 = 2 [(gogoproto.customname) = "FieldB"]; +} + +message NoExtensionsMap { + option (gogoproto.face) = false; + option (gogoproto.goproto_extensions_map) = false; + optional int64 Field1 = 1; + extensions 100 to 199; +} + +extend NoExtensionsMap { + optional double FieldA1 = 100; + optional NinOptNative FieldB1 = 101; + optional NinEmbeddedStruct FieldC1 = 102; +} + +message Unrecognized { + option (gogoproto.goproto_unrecognized) = false; + optional string Field1 = 1; +} + +message UnrecognizedWithInner { + message Inner { + option (gogoproto.goproto_unrecognized) = false; + optional uint32 Field1 = 1; + } + + repeated Inner embedded = 1; + optional string Field2 = 2; +} + +message UnrecognizedWithEmbed { + message Embedded { + option (gogoproto.goproto_unrecognized) = false; + optional uint32 Field1 = 1; + } + + optional Embedded embedded = 1 [(gogoproto.embed) = true, (gogoproto.nullable) = false]; + optional string Field2 = 2; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeunmarshaler/thetestpb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeunmarshaler/thetestpb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..0df9e7a2d3350d7e3287384528ca183824955202 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeunmarshaler/thetestpb_test.go @@ -0,0 +1,12939 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeunmarshaler/thetest.proto +// DO NOT EDIT! + +/* +Package test is a generated protocol buffer package. + +It is generated from these files: + combos/unsafeunmarshaler/thetest.proto + +It has these top-level messages: + NidOptNative + NinOptNative + NidRepNative + NinRepNative + NidRepPackedNative + NinRepPackedNative + NidOptStruct + NinOptStruct + NidRepStruct + NinRepStruct + NidEmbeddedStruct + NinEmbeddedStruct + NidNestedStruct + NinNestedStruct + NidOptCustom + CustomDash + NinOptCustom + NidRepCustom + NinRepCustom + NinOptNativeUnion + NinOptStructUnion + NinEmbeddedStructUnion + NinNestedStructUnion + Tree + OrBranch + AndBranch + Leaf + DeepTree + ADeepBranch + AndDeepBranch + DeepLeaf + Nil + NidOptEnum + NinOptEnum + NidRepEnum + NinRepEnum + NinOptEnumDefault + AnotherNinOptEnum + AnotherNinOptEnumDefault + Timer + MyExtendable + OtherExtenable + NestedDefinition + NestedScope + NinOptNativeDefault + CustomContainer + CustomNameNidOptNative + CustomNameNinOptNative + CustomNameNinRepNative + CustomNameNinStruct + CustomNameCustomType + CustomNameNinEmbeddedStructUnion + CustomNameEnum + NoExtensionsMap + Unrecognized + UnrecognizedWithInner + UnrecognizedWithEmbed +*/ +package test + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestNidOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepPackedNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidRepPackedNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepPackedNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepPackedNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepPackedNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepPackedNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepPackedNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinRepPackedNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepPackedNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepPackedNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepPackedNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepPackedNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidOptStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidRepStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinRepStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidEmbeddedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidEmbeddedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidEmbeddedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidEmbeddedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidEmbeddedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidEmbeddedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinEmbeddedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinEmbeddedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinEmbeddedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidNestedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidNestedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidNestedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidNestedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidNestedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidNestedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinNestedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinNestedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinNestedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidOptCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomDashProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomDashProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomDash, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomDash(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomDashProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomDash(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomDash{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidRepCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinRepCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptNativeUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNativeUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNativeUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinEmbeddedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinEmbeddedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinNestedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinNestedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinNestedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinNestedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestTreeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkTreeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Tree, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkTreeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTree(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Tree{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestOrBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkOrBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OrBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedOrBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkOrBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOrBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &OrBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAndBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAndBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAndBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AndBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestLeafProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkLeafProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Leaf, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkLeafProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLeaf(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Leaf{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepTreeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkDeepTreeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepTree, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedDeepTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkDeepTreeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepTree(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &DeepTree{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestADeepBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkADeepBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*ADeepBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedADeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkADeepBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedADeepBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &ADeepBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndDeepBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAndDeepBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndDeepBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAndDeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAndDeepBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndDeepBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AndDeepBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepLeafProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkDeepLeafProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepLeaf, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedDeepLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkDeepLeafProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepLeaf(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &DeepLeaf{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNilProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNilProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nil, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNil(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNilProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNil(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Nil{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidRepEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinRepEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptEnumDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnumDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptEnumDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnumDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptEnumDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAnotherNinOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAnotherNinOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AnotherNinOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAnotherNinOptEnumDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnumDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAnotherNinOptEnumDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnumDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AnotherNinOptEnumDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestTimerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkTimerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Timer, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedTimer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkTimerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTimer(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Timer{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMyExtendableProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkMyExtendableProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MyExtendable, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMyExtendable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMyExtendableProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMyExtendable(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &MyExtendable{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestOtherExtenableProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkOtherExtenableProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OtherExtenable, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedOtherExtenable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkOtherExtenableProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOtherExtenable(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &OtherExtenable{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinitionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNestedDefinitionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinitionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessageProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNestedDefinition_NestedMessageProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinition_NestedMessageProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition_NestedMessage{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedScopeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNestedScopeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedScope, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedScope(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedScopeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedScope(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedScope{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptNativeDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNativeDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNativeDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomContainerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomContainerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomContainer, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomContainer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomContainerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomContainer(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomContainer{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNidOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameNidOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNidOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNidOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNidOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNidOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameNinOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameNinRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameNinStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameCustomTypeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameCustomTypeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameCustomType, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameCustomType(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameCustomTypeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameCustomType(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameCustomType{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinEmbeddedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameNinEmbeddedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinEmbeddedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinEmbeddedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNoExtensionsMapProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNoExtensionsMapProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NoExtensionsMap, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNoExtensionsMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNoExtensionsMapProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNoExtensionsMap(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NoExtensionsMap{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkUnrecognizedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Unrecognized, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognized(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognized(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Unrecognized{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInnerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkUnrecognizedWithInnerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithInnerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithInner{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInner_InnerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkUnrecognizedWithInner_InnerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner_Inner, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithInner_InnerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner_Inner(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithInner_Inner{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkUnrecognizedWithEmbedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithEmbedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithEmbed{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbed_EmbeddedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed_Embedded, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithEmbed_Embedded{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepPackedNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepPackedNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidEmbeddedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinEmbeddedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidNestedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinNestedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomDashJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinEmbeddedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinNestedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTreeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOrBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAndBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestLeafJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestDeepTreeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestADeepBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAndDeepBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestDeepLeafJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNilJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptEnumDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAnotherNinOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAnotherNinOptEnumDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTimerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMyExtendableJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOtherExtenableJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinitionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinition_NestedMessageJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedScopeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomContainerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNidOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameCustomTypeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNoExtensionsMapJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithInnerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithInner_InnerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithEmbedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithEmbed_EmbeddedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepPackedNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepPackedNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepPackedNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepPackedNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidEmbeddedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidEmbeddedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidNestedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidNestedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomDashProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomDashProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTreeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTreeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOrBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOrBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestLeafProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestLeafProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepTreeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepTreeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestADeepBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestADeepBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndDeepBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndDeepBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepLeafProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepLeafProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNilProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNilProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTimerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTimerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMyExtendableProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMyExtendableProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOtherExtenableProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOtherExtenableProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinitionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinitionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessageProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessageProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedScopeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedScopeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomContainerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomContainerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNidOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNidOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameCustomTypeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameCustomTypeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinEmbeddedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinEmbeddedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNoExtensionsMapProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNoExtensionsMapProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInnerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInnerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInner_InnerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInner_InnerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestThetestDescription(t *testing.T) { + ThetestDescription() +} +func TestNidOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepPackedNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepPackedNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidEmbeddedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinEmbeddedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidNestedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinNestedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomDashVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinNestedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTreeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOrBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAndBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestLeafVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestDeepTreeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestADeepBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAndDeepBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestDeepLeafVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNilVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptEnumDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAnotherNinOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAnotherNinOptEnumDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTimerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMyExtendableVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOtherExtenableVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinitionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinition_NestedMessageVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedScopeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomContainerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNidOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameCustomTypeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNoExtensionsMapVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithInnerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithInner_InnerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithEmbedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithEmbed_EmbeddedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepPackedNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepPackedNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidEmbeddedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidNestedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinNestedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomDashFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptNativeUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinNestedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestTreeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestOrBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAndBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestLeafFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestDeepTreeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestADeepBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAndDeepBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestDeepLeafFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNilFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAnotherNinOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestTimerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinitionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinition_NestedMessageFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedScopeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomContainerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNidOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameCustomTypeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithInnerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithInner_InnerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithEmbedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithEmbed_EmbeddedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepPackedNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepPackedNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidEmbeddedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinEmbeddedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidNestedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinNestedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomDashGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinEmbeddedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinNestedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTreeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOrBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAndBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestLeafGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestDeepTreeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestADeepBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAndDeepBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestDeepLeafGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNilGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptEnumDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAnotherNinOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAnotherNinOptEnumDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTimerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMyExtendableGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOtherExtenableGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinitionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinition_NestedMessageGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedScopeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomContainerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNidOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameCustomTypeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinEmbeddedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNoExtensionsMapGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithInnerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithInner_InnerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithEmbedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithEmbed_EmbeddedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepPackedNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepPackedNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepPackedNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepPackedNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepPackedNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepPackedNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidEmbeddedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidEmbeddedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidEmbeddedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinEmbeddedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidNestedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidNestedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidNestedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinNestedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomDashSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomDashSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomDash, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomDash(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNativeUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinEmbeddedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinNestedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinNestedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestTreeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkTreeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Tree, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestOrBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkOrBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OrBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedOrBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAndBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAndBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestLeafSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkLeafSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Leaf, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepTreeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkDeepTreeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepTree, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedDeepTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestADeepBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkADeepBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*ADeepBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedADeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndDeepBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAndDeepBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndDeepBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAndDeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepLeafSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkDeepLeafSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepLeaf, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedDeepLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNilSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNilSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nil, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNil(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptEnumDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnumDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAnotherNinOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAnotherNinOptEnumDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnumDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestTimerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkTimerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Timer, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedTimer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMyExtendableSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMyExtendableSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MyExtendable, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMyExtendable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestOtherExtenableSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkOtherExtenableSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OtherExtenable, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedOtherExtenable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinitionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinitionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessageSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinition_NestedMessageSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedScopeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedScopeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedScope, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedScope(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNativeDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomContainerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomContainerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomContainer, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomContainer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNidOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNidOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNidOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameCustomTypeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameCustomTypeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameCustomType, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameCustomType(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinEmbeddedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinEmbeddedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinEmbeddedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNoExtensionsMapSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNoExtensionsMapSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NoExtensionsMap, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNoExtensionsMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Unrecognized, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognized(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInnerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithInnerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInner_InnerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithInner_InnerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner_Inner, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithEmbedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbed_EmbeddedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed_Embedded, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepPackedNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepPackedNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidEmbeddedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinEmbeddedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidNestedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinNestedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomDashStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinEmbeddedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinNestedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTreeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOrBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAndBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestLeafStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestDeepTreeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestADeepBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAndDeepBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestDeepLeafStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNilStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptEnumDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAnotherNinOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAnotherNinOptEnumDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTimerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestMyExtendableStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOtherExtenableStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinitionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinition_NestedMessageStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedScopeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomContainerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNidOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameCustomTypeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinEmbeddedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNoExtensionsMapStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithInnerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithInner_InnerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithEmbedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithEmbed_EmbeddedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, true) + v := p.GetValue() + msg := &NinOptNativeUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinOptStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, true) + v := p.GetValue() + msg := &NinOptStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + v := p.GetValue() + msg := &NinEmbeddedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinNestedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, true) + v := p.GetValue() + msg := &NinNestedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestTreeOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, true) + v := p.GetValue() + msg := &Tree{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestDeepTreeOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, true) + v := p.GetValue() + msg := &DeepTree{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + v := p.GetValue() + msg := &CustomNameNinEmbeddedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeunmarshaler/uuid.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeunmarshaler/uuid.go new file mode 100644 index 0000000000000000000000000000000000000000..4c071114bcce237893cd1f0fa4baca9d8663b571 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/unsafeunmarshaler/uuid.go @@ -0,0 +1,122 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 test + +import ( + "bytes" + "encoding/json" +) + +func PutLittleEndianUint64(b []byte, offset int, v uint64) { + b[offset] = byte(v) + b[offset+1] = byte(v >> 8) + b[offset+2] = byte(v >> 16) + b[offset+3] = byte(v >> 24) + b[offset+4] = byte(v >> 32) + b[offset+5] = byte(v >> 40) + b[offset+6] = byte(v >> 48) + b[offset+7] = byte(v >> 56) +} + +type Uuid []byte + +func (uuid Uuid) Marshal() ([]byte, error) { + if len(uuid) == 0 { + return nil, nil + } + return []byte(uuid), nil +} + +func (uuid Uuid) MarshalTo(data []byte) (n int, err error) { + if len(uuid) == 0 { + return 0, nil + } + copy(data, uuid) + return 16, nil +} + +func (uuid *Uuid) Unmarshal(data []byte) error { + if len(data) == 0 { + uuid = nil + return nil + } + id := Uuid(make([]byte, 16)) + copy(id, data) + *uuid = id + return nil +} + +func (uuid *Uuid) Size() int { + if uuid == nil { + return 0 + } + if len(*uuid) == 0 { + return 0 + } + return 16 +} + +func (uuid Uuid) MarshalJSON() ([]byte, error) { + return json.Marshal([]byte(uuid)) +} + +func (uuid *Uuid) UnmarshalJSON(data []byte) error { + v := new([]byte) + err := json.Unmarshal(data, v) + if err != nil { + return err + } + return uuid.Unmarshal(*v) +} + +func (uuid Uuid) Equal(other Uuid) bool { + return bytes.Equal(uuid[0:], other[0:]) +} + +type int63 interface { + Int63() int64 +} + +func NewPopulatedUuid(r int63) *Uuid { + u := RandV4(r) + return &u +} + +func RandV4(r int63) Uuid { + uuid := make(Uuid, 16) + uuid.RandV4(r) + return uuid +} + +func (uuid Uuid) RandV4(r int63) { + PutLittleEndianUint64(uuid, 0, uint64(r.Int63())) + PutLittleEndianUint64(uuid, 8, uint64(r.Int63())) + uuid[6] = (uuid[6] & 0xf) | 0x40 + uuid[8] = (uuid[8] & 0x3f) | 0x80 +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom-dash-type/customdash.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom-dash-type/customdash.go new file mode 100644 index 0000000000000000000000000000000000000000..8f202fcece543220c3c595dbb3fd23a0bf371b80 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom-dash-type/customdash.go @@ -0,0 +1,98 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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 custom contains custom types for test and example purposes. + These types are used by the test structures generated by gogoprotobuf. +*/ +package custom + +import ( + "bytes" + "encoding/json" +) + +type Bytes []byte + +func (b Bytes) Marshal() ([]byte, error) { + buffer := make([]byte, len(b)) + _, err := b.MarshalTo(buffer) + return buffer, err +} + +func (b Bytes) MarshalTo(data []byte) (n int, err error) { + copy(data, b) + return len(b), nil +} + +func (b *Bytes) Unmarshal(data []byte) error { + if data == nil { + b = nil + return nil + } + pb := make([]byte, len(data)) + copy(pb, data) + *b = pb + return nil +} + +func (b Bytes) MarshalJSON() ([]byte, error) { + data, err := b.Marshal() + if err != nil { + return nil, err + } + return json.Marshal(data) +} + +func (b *Bytes) Size() int { + return len(*b) +} + +func (b *Bytes) UnmarshalJSON(data []byte) error { + v := new([]byte) + err := json.Unmarshal(data, v) + if err != nil { + return err + } + return b.Unmarshal(*v) +} + +func (this Bytes) Equal(that Bytes) bool { + return bytes.Equal(this, that) +} + +type randy interface { + Intn(n int) int +} + +func NewPopulatedBytes(r randy) *Bytes { + l := r.Intn(100) + data := Bytes(make([]byte, l)) + for i := 0; i < l; i++ { + data[i] = byte(r.Intn(255)) + } + return &data +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom/custom.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom/custom.go new file mode 100644 index 0000000000000000000000000000000000000000..62f18c00ba7fb14884337d7be8bd80e7245593e1 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom/custom.go @@ -0,0 +1,132 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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 custom contains custom types for test and example purposes. + These types are used by the test structures generated by gogoprotobuf. +*/ +package custom + +import ( + "encoding/json" + "errors" + "unsafe" +) + +type Uint128 [2]uint64 + +func (u Uint128) Marshal() ([]byte, error) { + buffer := make([]byte, 16) + _, err := u.MarshalTo(buffer) + return buffer, err +} + +func (u Uint128) MarshalTo(data []byte) (n int, err error) { + PutLittleEndianUint128(data, 0, u) + return 16, nil +} + +func GetLittleEndianUint64(b []byte, offset int) uint64 { + return *(*uint64)(unsafe.Pointer(&b[offset])) +} + +func PutLittleEndianUint64(b []byte, offset int, v uint64) { + b[offset] = byte(v) + b[offset+1] = byte(v >> 8) + b[offset+2] = byte(v >> 16) + b[offset+3] = byte(v >> 24) + b[offset+4] = byte(v >> 32) + b[offset+5] = byte(v >> 40) + b[offset+6] = byte(v >> 48) + b[offset+7] = byte(v >> 56) +} + +func PutLittleEndianUint128(buffer []byte, offset int, v [2]uint64) { + PutLittleEndianUint64(buffer, offset, v[0]) + PutLittleEndianUint64(buffer, offset+8, v[1]) +} + +func GetLittleEndianUint128(buffer []byte, offset int) (value [2]uint64) { + value[0] = GetLittleEndianUint64(buffer, offset) + value[1] = GetLittleEndianUint64(buffer, offset+8) + return +} + +func (u *Uint128) Unmarshal(data []byte) error { + if data == nil { + u = nil + return nil + } + if len(data) == 0 { + pu := Uint128{} + *u = pu + return nil + } + if len(data) != 16 { + return errors.New("Uint128: invalid length") + } + pu := Uint128(GetLittleEndianUint128(data, 0)) + *u = pu + return nil +} + +func (u Uint128) MarshalJSON() ([]byte, error) { + data, err := u.Marshal() + if err != nil { + return nil, err + } + return json.Marshal(data) +} + +func (u *Uint128) Size() int { + return 16 +} + +func (u *Uint128) UnmarshalJSON(data []byte) error { + v := new([]byte) + err := json.Unmarshal(data, v) + if err != nil { + return err + } + return u.Unmarshal(*v) +} + +func (this Uint128) Equal(that Uint128) bool { + return this == that +} + +type randy interface { + Intn(n int) int +} + +func NewPopulatedUint128(r randy) *Uint128 { + data := make([]byte, 16) + for i := 0; i < 16; i++ { + data[i] = byte(r.Intn(255)) + } + u := Uint128(GetLittleEndianUint128(data, 0)) + return &u +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom/custom_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom/custom_test.go new file mode 100644 index 0000000000000000000000000000000000000000..d1e4fcc291b31e2f46e40849596afa99a1655764 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom/custom_test.go @@ -0,0 +1,41 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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 custom + +import ( + "testing" +) + +func TestUint128(t *testing.T) { + var uint128a = Uint128{0, 1} + buf := make([]byte, 16) + PutLittleEndianUint128(buf, 0, uint128a) + uint128b := GetLittleEndianUint128(buf, 0) + if !uint128a.Equal(uint128b) { + t.Fatalf("%v != %v", uint128a, uint128b) + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custombytesnonstruct/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custombytesnonstruct/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..e6a2cc3c9f571cc8704b5f7c8d4fdcf30c80862d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custombytesnonstruct/Makefile @@ -0,0 +1,30 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. proto.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custombytesnonstruct/custombytesnonstruct_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custombytesnonstruct/custombytesnonstruct_test.go new file mode 100644 index 0000000000000000000000000000000000000000..680529cfd1d50a680483f48c0cc7ee92f675a9af --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custombytesnonstruct/custombytesnonstruct_test.go @@ -0,0 +1,6 @@ +package custombytesnonstruct + +import testing "testing" + +func TestCustomBytesNonStruct(t *testing.T) { +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custombytesnonstruct/customtype.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custombytesnonstruct/customtype.go new file mode 100644 index 0000000000000000000000000000000000000000..8f0ed3aeefad480b7e451dff60a5ab79537fa51d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custombytesnonstruct/customtype.go @@ -0,0 +1,8 @@ +package custombytesnonstruct + +type CustomType int + +func (c *CustomType) Unmarshal(data []byte) error { + data[0] = 42 + return nil +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custombytesnonstruct/proto.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custombytesnonstruct/proto.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..1d60f2706c98b36d8e3e7f0dd037eda61105ae1d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custombytesnonstruct/proto.pb.go @@ -0,0 +1,257 @@ +// Code generated by protoc-gen-gogo. +// source: proto.proto +// DO NOT EDIT! + +/* + Package custombytesnonstruct is a generated protocol buffer package. + + It is generated from these files: + proto.proto + + It has these top-level messages: + Object +*/ +package custombytesnonstruct + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Object struct { + CustomField1 *CustomType `protobuf:"bytes,1,opt,name=CustomField1,customtype=CustomType" json:"CustomField1,omitempty"` + CustomField2 []CustomType `protobuf:"bytes,2,rep,name=CustomField2,customtype=CustomType" json:"CustomField2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Object) Reset() { *m = Object{} } +func (m *Object) String() string { return proto.CompactTextString(m) } +func (*Object) ProtoMessage() {} + +func (m *Object) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProto + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Object: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Object: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CustomField1", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProto + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthProto + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v CustomType + m.CustomField1 = &v + if err := m.CustomField1.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CustomField2", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProto + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthProto + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v CustomType + m.CustomField2 = append(m.CustomField2, v) + if err := m.CustomField2[len(m.CustomField2)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipProto(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthProto + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipProto(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthProto + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipProto(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthProto = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowProto = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custombytesnonstruct/proto.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custombytesnonstruct/proto.proto new file mode 100644 index 0000000000000000000000000000000000000000..a0f0016daee7abb3a05770e231a5147a86083229 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custombytesnonstruct/proto.proto @@ -0,0 +1,11 @@ +syntax = "proto2"; +package custombytesnonstruct; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.unmarshaler_all) = true; + +message Object { + optional bytes CustomField1 = 1 [(gogoproto.customtype) = "CustomType"]; + repeated bytes CustomField2 = 2 [(gogoproto.customtype) = "CustomType"]; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/dashfilename/dash-filename.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/dashfilename/dash-filename.proto new file mode 100644 index 0000000000000000000000000000000000000000..1ae5aa6f355d5fed6bcc4bb61b4992474ae9f4e7 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/dashfilename/dash-filename.proto @@ -0,0 +1,10 @@ +syntax = "proto2"; +package dashfilename; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.marshaler_all) = true; + +message test { + +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/dashfilename/df_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/dashfilename/df_test.go new file mode 100644 index 0000000000000000000000000000000000000000..2f54a98fd4465bd7500cf1c726fa63bc7cc273ed --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/dashfilename/df_test.go @@ -0,0 +1,20 @@ +package dashfilename + +import ( + "os" + "os/exec" + "testing" +) + +//Issue 16 : https://github.com/gogo/protobuf/issues/detail?id=16 +func TestDashFilename(t *testing.T) { + name := "dash-filename" + cmd := exec.Command("protoc", "--gogo_out=.", "-I=../../../../../:../../protobuf/:.", name+".proto") + data, err := cmd.CombinedOutput() + if err != nil { + t.Fatalf("err = %v: %s", err, string(data)) + } + if err := os.Remove(name + ".pb.go"); err != nil { + panic(err) + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/dashfilename/doc.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/dashfilename/doc.go new file mode 100644 index 0000000000000000000000000000000000000000..b288f33e75e9ceefcb8ca9c1d675e9a310912776 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/dashfilename/doc.go @@ -0,0 +1 @@ +package dashfilename diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/df.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/df.proto new file mode 100644 index 0000000000000000000000000000000000000000..359458e9135b5360bf184e40eaa9ef1bfbf9b565 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/df.proto @@ -0,0 +1,38 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package defaultcheck; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.face_all) = true; +option (gogoproto.goproto_getters_all) = false; + +message A { + optional int64 Field1 = 1 [default=1234]; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/dg.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/dg.proto new file mode 100644 index 0000000000000000000000000000000000000000..80e7cac84de2d91dd32ca61ebf2b9d1b23682337 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/dg.proto @@ -0,0 +1,37 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package defaultcheck; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_getters_all) = false; + +message A { + optional int64 Field1 = 1 [default=1234]; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/doc.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/doc.go new file mode 100644 index 0000000000000000000000000000000000000000..9762d20388b92135a7d41be5d2f9be5b168c72f6 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/doc.go @@ -0,0 +1 @@ +package defaultcheck diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/nc.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/nc.proto new file mode 100644 index 0000000000000000000000000000000000000000..a7c7bfec8e68aff20c4d475fcc1cdcf297218f39 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/nc.proto @@ -0,0 +1,35 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package defaultcheck; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +message A { + optional int64 Field1 = 1 [default = 1234, (gogoproto.nullable) = false];; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/nc_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/nc_test.go new file mode 100644 index 0000000000000000000000000000000000000000..8426c5f10a1ef281ebd65ecdfa87da5040697629 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/nc_test.go @@ -0,0 +1,66 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 defaultcheck + +import ( + "os" + "os/exec" + "strings" + "testing" +) + +func testDefaultConflict(t *testing.T, name string) { + cmd := exec.Command("protoc", "--gogo_out=.", "-I=../../../../../:../../protobuf/:.", name+".proto") + data, err := cmd.CombinedOutput() + if err == nil && !strings.Contains(string(data), "Plugin failed with status code 1") { + t.Errorf("Expected error, got: %s", data) + if err := os.Remove(name + ".pb.go"); err != nil { + t.Error(err) + } + } + t.Logf("received expected error = %v and output = %v", err, string(data)) +} + +func TestNullableDefault(t *testing.T) { + testDefaultConflict(t, "nc") +} + +func TestNullableExtension(t *testing.T) { + testDefaultConflict(t, "nx") +} + +func TestNullableEnum(t *testing.T) { + testDefaultConflict(t, "ne") +} + +func TestFaceDefault(t *testing.T) { + testDefaultConflict(t, "df") +} + +func TestNoGettersDefault(t *testing.T) { + testDefaultConflict(t, "dg") +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/ne.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/ne.proto new file mode 100644 index 0000000000000000000000000000000000000000..9266fed073dbc923429545b3152bde39196b7d88 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/ne.proto @@ -0,0 +1,40 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package defaultcheck; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +enum E { + P = 10; + Q = 11; +} + +message A { + optional E Field1 = 1 [(gogoproto.nullable) = false]; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/nx.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/nx.proto new file mode 100644 index 0000000000000000000000000000000000000000..20b3d95a806c1820d73c750ee51c74289894334e --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/defaultconflict/nx.proto @@ -0,0 +1,39 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package defaultcheck; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +message A { + extensions 1 to max; +} + +extend A { + optional int64 Field1 = 1 [(gogoproto.nullable) = false]; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/.gitignore b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..c61a5e8b01255cc9de6912fd74b6819c53d3aca2 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/.gitignore @@ -0,0 +1 @@ +*.pb.go diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/doc.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/doc.go new file mode 100644 index 0000000000000000000000000000000000000000..484e94831294cc13cad9b944b10296286608a4ee --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/doc.go @@ -0,0 +1 @@ +package embedconflict diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/eb.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/eb.proto new file mode 100644 index 0000000000000000000000000000000000000000..73bbe26164545c523221327ff0eee4f016224390 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/eb.proto @@ -0,0 +1,36 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package embedconflict; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +message TakesLongTooDebug { + optional bytes Field1 = 1; + optional bytes Field2 = 2 [(gogoproto.nullable)=false, (gogoproto.embed)=true]; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/ec.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/ec.proto new file mode 100644 index 0000000000000000000000000000000000000000..b2092903957b0d89a16b29cf5de9ac9c249b393c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/ec.proto @@ -0,0 +1,38 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 embedconflict; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +message A { + optional int64 Field1 = 1; + optional B B = 2 [(gogoproto.embed) = true]; +} + +message B { + optional double Field1 = 1; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/ec_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/ec_test.go new file mode 100644 index 0000000000000000000000000000000000000000..5ace369dad17b26ce4560cd77b6f715b980ec43c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/ec_test.go @@ -0,0 +1,117 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 embedconflict + +import ( + "os" + "os/exec" + "strings" + "testing" +) + +func TestEmbedConflict(t *testing.T) { + cmd := exec.Command("protoc", "--gogo_out=.", "-I=../../../../../:../../protobuf/:.", "ec.proto") + data, err := cmd.CombinedOutput() + if err == nil && !strings.Contains(string(data), "Plugin failed with status code 1") { + t.Errorf("Expected error, got: %s", data) + if err := os.Remove("ec.pb.go"); err != nil { + t.Error(err) + } + } + t.Logf("received expected error = %v and output = %v", err, string(data)) +} + +func TestEmbedMarshaler(t *testing.T) { + cmd := exec.Command("protoc", "--gogo_out=.", "-I=../../../../../:../../protobuf/:.", "em.proto") + data, err := cmd.CombinedOutput() + dataStr := string(data) + t.Logf("received error = %v and output = %v", err, dataStr) + if !strings.Contains(dataStr, "WARNING: found non-") || !strings.Contains(dataStr, "unsafe_marshaler") { + t.Errorf("Expected WARNING: found non-[marshaler unsafe_marshaler] C with embedded marshaler D") + } + if err := os.Remove("em.pb.go"); err != nil { + t.Error(err) + } +} + +func TestEmbedExtend(t *testing.T) { + cmd := exec.Command("protoc", "--gogo_out=.", "-I=../../../../../:../../protobuf/:.", "ee.proto") + data, err := cmd.CombinedOutput() + if err == nil && !strings.Contains(string(data), "Plugin failed with status code 1") { + t.Errorf("Expected error, got: %s", data) + if err := os.Remove("ee.pb.go"); err != nil { + t.Error(err) + } + } + t.Logf("received expected error = %v and output = %v", err, string(data)) +} + +func TestCustomName(t *testing.T) { + cmd := exec.Command("protoc", "--gogo_out=.", "-I=../../../../../:../../protobuf/:.", "en.proto") + data, err := cmd.CombinedOutput() + if err == nil && !strings.Contains(string(data), "Plugin failed with status code 1") { + t.Errorf("Expected error, got: %s", data) + if err := os.Remove("en.pb.go"); err != nil { + t.Error(err) + } + } + t.Logf("received expected error = %v and output = %v", err, string(data)) +} + +func TestRepeatedEmbed(t *testing.T) { + cmd := exec.Command("protoc", "--gogo_out=.", "-I=../../../../../:../../protobuf/:.", "er.proto") + data, err := cmd.CombinedOutput() + if err == nil && !strings.Contains(string(data), "Plugin failed with status code 1") { + t.Errorf("Expected error, got: %s", data) + if err := os.Remove("er.pb.go"); err != nil { + t.Error(err) + } + } + dataStr := string(data) + t.Logf("received error = %v and output = %v", err, dataStr) + warning := "ERROR: found repeated embedded field B in message A" + if !strings.Contains(dataStr, warning) { + t.Errorf("Expected " + warning) + } +} + +func TestTakesTooLongToDebug(t *testing.T) { + cmd := exec.Command("protoc", "--gogo_out=.", "-I=../../../../../:../../protobuf/:.", "eb.proto") + data, err := cmd.CombinedOutput() + if err == nil && !strings.Contains(string(data), "Plugin failed with status code 1") { + t.Errorf("Expected error, got: %s", data) + if err := os.Remove("eb.pb.go"); err != nil { + t.Error(err) + } + } + dataStr := string(data) + t.Logf("received error = %v and output = %v", err, dataStr) + warning := "ERROR: found embedded bytes field" + if !strings.Contains(dataStr, warning) { + t.Errorf("Expected " + warning) + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/ee.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/ee.proto new file mode 100644 index 0000000000000000000000000000000000000000..0bc805fd3fc21e978dbc613499ff2ea5135620bc --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/ee.proto @@ -0,0 +1,39 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package embedconflict; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +message E { + optional int64 Field1 = 1; + extensions 100 to 199; +} + +extend E { + optional int64 Field1 = 100 [(gogoproto.embed) = true]; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/em.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/em.proto new file mode 100644 index 0000000000000000000000000000000000000000..990ec7678963fa267d9de523bb4b672d028c96dd --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/em.proto @@ -0,0 +1,40 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package embedconflict; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +message C { + optional int64 Field1 = 1; + optional D D = 2 [(gogoproto.embed) = true]; +} + +message D { + option (gogoproto.marshaler) = true; + optional double Field2 = 2; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/en.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/en.proto new file mode 100644 index 0000000000000000000000000000000000000000..18b65c4946450307848447d8be810654ca216a7d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/en.proto @@ -0,0 +1,38 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package embedconflict; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +message F { + optional G G = 2 [(gogoproto.embed) = true, (gogoproto.customname) = "G"]; +} + +message G { + optional int64 Field1 = 1; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/er.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/er.proto new file mode 100644 index 0000000000000000000000000000000000000000..2c647d8f1be5b7c0f83b262cf224a2948c7f0db5 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/embedconflict/er.proto @@ -0,0 +1,39 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package embedconflict; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +message A { + optional int64 Field1 = 1; + repeated B B = 2 [(gogoproto.embed) = true]; +} + +message B { + optional double Field2 = 2; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/empty-issue70/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/empty-issue70/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..43928f03bd141e49d495933cee7a23398db20756 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/empty-issue70/Makefile @@ -0,0 +1,30 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. empty.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/empty-issue70/empty.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/empty-issue70/empty.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..e63736c9867da13c40064652d74f73e7ffca7af7 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/empty-issue70/empty.pb.go @@ -0,0 +1,191 @@ +// Code generated by protoc-gen-gogo. +// source: empty.proto +// DO NOT EDIT! + +/* +Package empty is a generated protocol buffer package. + +It is generated from these files: + empty.proto + +It has these top-level messages: + TestRequest +*/ +package empty + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type TestRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *TestRequest) Reset() { *m = TestRequest{} } +func (m *TestRequest) String() string { return proto.CompactTextString(m) } +func (*TestRequest) ProtoMessage() {} + +func (m *TestRequest) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEmpty + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TestRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TestRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipEmpty(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthEmpty + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipEmpty(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEmpty + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEmpty + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEmpty + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthEmpty + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEmpty + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipEmpty(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthEmpty = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowEmpty = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/empty-issue70/empty.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/empty-issue70/empty.proto new file mode 100644 index 0000000000000000000000000000000000000000..eeda2d1be6bd0bfd08f434bfd59e69f5ce1501ba --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/empty-issue70/empty.proto @@ -0,0 +1,11 @@ +syntax="proto2"; + +package empty; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.unmarshaler_all) = true; + +message TestRequest { + +} \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/empty-issue70/empty_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/empty-issue70/empty_test.go new file mode 100644 index 0000000000000000000000000000000000000000..fa821d932f3be553db79499bfad860f192441caa --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/empty-issue70/empty_test.go @@ -0,0 +1,9 @@ +package empty + +import ( + "testing" +) + +func TestEmpty(t *testing.T) { + +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumprefix/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumprefix/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..d5fc83d83a28afcb827515328db8132036add4bc --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumprefix/Makefile @@ -0,0 +1,30 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. enumprefix.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumprefix/enumprefix.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumprefix/enumprefix.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..01c9a564e668295fad96afac3bc3eba89b1a1b90 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumprefix/enumprefix.pb.go @@ -0,0 +1,42 @@ +// Code generated by protoc-gen-gogo. +// source: enumprefix.proto +// DO NOT EDIT! + +/* + Package enumprefix is a generated protocol buffer package. + + It is generated from these files: + enumprefix.proto + + It has these top-level messages: + MyMessage +*/ +package enumprefix + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" +import test "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type MyMessage struct { + TheField test.TheTestEnum `protobuf:"varint,1,opt,name=TheField,enum=test.TheTestEnum" json:"TheField"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MyMessage) Reset() { *m = MyMessage{} } +func (m *MyMessage) String() string { return proto.CompactTextString(m) } +func (*MyMessage) ProtoMessage() {} + +func (m *MyMessage) GetTheField() test.TheTestEnum { + if m != nil { + return m.TheField + } + return test.A +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumprefix/enumprefix.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumprefix/enumprefix.proto new file mode 100644 index 0000000000000000000000000000000000000000..121001d52683f87cfd7e2de127a0c228ed7427e5 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumprefix/enumprefix.proto @@ -0,0 +1,35 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package enumprefix; + +import "github.com/gogo/protobuf/test/thetest.proto"; +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +message MyMessage { + optional test.TheTestEnum TheField = 1 [(gogoproto.nullable) = false]; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumstringer/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumstringer/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..4327b48e75ee2811d129647e0f32a9131c8d942b --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumstringer/Makefile @@ -0,0 +1,30 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. enumstringer.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumstringer/enumstringer.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumstringer/enumstringer.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..4dc5ee6dccc7cb003fe1e55336c7c255130b7f53 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumstringer/enumstringer.pb.go @@ -0,0 +1,513 @@ +// Code generated by protoc-gen-gogo. +// source: enumstringer.proto +// DO NOT EDIT! + +/* +Package enumstringer is a generated protocol buffer package. + +It is generated from these files: + enumstringer.proto + +It has these top-level messages: + NidOptEnum + NinOptEnum + NidRepEnum + NinRepEnum +*/ +package enumstringer + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import bytes "bytes" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type TheTestEnum int32 + +const ( + TheTestEnum_A TheTestEnum = 0 + TheTestEnum_B TheTestEnum = 1 + TheTestEnum_C TheTestEnum = 2 +) + +var TheTestEnum_name = map[int32]string{ + 0: "A", + 1: "B", + 2: "C", +} +var TheTestEnum_value = map[string]int32{ + "A": 0, + "B": 1, + "C": 2, +} + +func (x TheTestEnum) Enum() *TheTestEnum { + p := new(TheTestEnum) + *p = x + return p +} +func (x TheTestEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(TheTestEnum_name, int32(x)) +} +func (x *TheTestEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(TheTestEnum_value, data, "TheTestEnum") + if err != nil { + return err + } + *x = TheTestEnum(value) + return nil +} + +type NidOptEnum struct { + Field1 TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=enumstringer.TheTestEnum" json:"Field1"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptEnum) Reset() { *m = NidOptEnum{} } +func (m *NidOptEnum) String() string { return proto.CompactTextString(m) } +func (*NidOptEnum) ProtoMessage() {} + +func (m *NidOptEnum) GetField1() TheTestEnum { + if m != nil { + return m.Field1 + } + return TheTestEnum_A +} + +type NinOptEnum struct { + Field1 *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=enumstringer.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptEnum) Reset() { *m = NinOptEnum{} } +func (m *NinOptEnum) String() string { return proto.CompactTextString(m) } +func (*NinOptEnum) ProtoMessage() {} + +func (m *NinOptEnum) GetField1() TheTestEnum { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return TheTestEnum_A +} + +type NidRepEnum struct { + Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=enumstringer.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepEnum) Reset() { *m = NidRepEnum{} } +func (m *NidRepEnum) String() string { return proto.CompactTextString(m) } +func (*NidRepEnum) ProtoMessage() {} + +func (m *NidRepEnum) GetField1() []TheTestEnum { + if m != nil { + return m.Field1 + } + return nil +} + +type NinRepEnum struct { + Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=enumstringer.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepEnum) Reset() { *m = NinRepEnum{} } +func (m *NinRepEnum) String() string { return proto.CompactTextString(m) } +func (*NinRepEnum) ProtoMessage() {} + +func (m *NinRepEnum) GetField1() []TheTestEnum { + if m != nil { + return m.Field1 + } + return nil +} + +func init() { + proto.RegisterEnum("enumstringer.TheTestEnum", TheTestEnum_name, TheTestEnum_value) +} +func (this *NidOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptEnum) + if !ok { + return fmt.Errorf("that is not of type *NidOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptEnumbut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptEnum) + if !ok { + return fmt.Errorf("that is not of type *NinOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptEnumbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepEnum) + if !ok { + return fmt.Errorf("that is not of type *NidRepEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepEnumbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepEnum) + if !ok { + return fmt.Errorf("that is not of type *NinRepEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepEnumbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func NewPopulatedNidOptEnum(r randyEnumstringer, easy bool) *NidOptEnum { + this := &NidOptEnum{} + this.Field1 = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedEnumstringer(r, 2) + } + return this +} + +func NewPopulatedNinOptEnum(r randyEnumstringer, easy bool) *NinOptEnum { + this := &NinOptEnum{} + if r.Intn(10) != 0 { + v1 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.Field1 = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedEnumstringer(r, 2) + } + return this +} + +func NewPopulatedNidRepEnum(r randyEnumstringer, easy bool) *NidRepEnum { + this := &NidRepEnum{} + if r.Intn(10) != 0 { + v2 := r.Intn(10) + this.Field1 = make([]TheTestEnum, v2) + for i := 0; i < v2; i++ { + this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedEnumstringer(r, 2) + } + return this +} + +func NewPopulatedNinRepEnum(r randyEnumstringer, easy bool) *NinRepEnum { + this := &NinRepEnum{} + if r.Intn(10) != 0 { + v3 := r.Intn(10) + this.Field1 = make([]TheTestEnum, v3) + for i := 0; i < v3; i++ { + this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedEnumstringer(r, 2) + } + return this +} + +type randyEnumstringer interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneEnumstringer(r randyEnumstringer) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringEnumstringer(r randyEnumstringer) string { + v4 := r.Intn(100) + tmps := make([]rune, v4) + for i := 0; i < v4; i++ { + tmps[i] = randUTF8RuneEnumstringer(r) + } + return string(tmps) +} +func randUnrecognizedEnumstringer(r randyEnumstringer, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldEnumstringer(data, r, fieldNumber, wire) + } + return data +} +func randFieldEnumstringer(data []byte, r randyEnumstringer, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateEnumstringer(data, uint64(key)) + v5 := r.Int63() + if r.Intn(2) == 0 { + v5 *= -1 + } + data = encodeVarintPopulateEnumstringer(data, uint64(v5)) + case 1: + data = encodeVarintPopulateEnumstringer(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateEnumstringer(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateEnumstringer(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateEnumstringer(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateEnumstringer(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumstringer/enumstringer.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumstringer/enumstringer.proto new file mode 100644 index 0000000000000000000000000000000000000000..f44f02fbb019c6b8c23eda18125bf1f01c8d607e --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumstringer/enumstringer.proto @@ -0,0 +1,60 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package enumstringer; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_enum_stringer_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; + +enum TheTestEnum { + A = 0; + B = 1; + C = 2; +} + +message NidOptEnum { + optional TheTestEnum Field1 = 1 [(gogoproto.nullable) = false]; +} + +message NinOptEnum { + optional TheTestEnum Field1 = 1; +} + +message NidRepEnum { + repeated TheTestEnum Field1 = 1 [(gogoproto.nullable) = false]; +} + +message NinRepEnum { + repeated TheTestEnum Field1 = 1; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumstringer/enumstringerpb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumstringer/enumstringerpb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..1c4bfe24fb709f2d3dd9ecabd2960bebf0159bc6 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumstringer/enumstringerpb_test.go @@ -0,0 +1,452 @@ +// Code generated by protoc-gen-gogo. +// source: enumstringer.proto +// DO NOT EDIT! + +/* +Package enumstringer is a generated protocol buffer package. + +It is generated from these files: + enumstringer.proto + +It has these top-level messages: + NidOptEnum + NinOptEnum + NidRepEnum + NinRepEnum +*/ +package enumstringer + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestNidOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidRepEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNinRepEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNidOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumstringer/string.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumstringer/string.go new file mode 100644 index 0000000000000000000000000000000000000000..c9ebfa45e1fbca495e3b66591170a7474ddb2f89 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/enumstringer/string.go @@ -0,0 +1,39 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 enumstringer + +func (this TheTestEnum) String() string { + switch this { + case 0: + return "a" + case 1: + return "blabla" + case 2: + return "z" + } + return "3" +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/example/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/example/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..c323d9ee7081b55b97801e8c194520e7f7f81015 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/example/Makefile @@ -0,0 +1,30 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. example.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/example/example.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/example/example.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..ec74960e57b0453bc33fd7c8975d67caf274baf1 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/example/example.pb.go @@ -0,0 +1,3723 @@ +// Code generated by protoc-gen-gogo. +// source: example.proto +// DO NOT EDIT! + +/* + Package test is a generated protocol buffer package. + + It is generated from these files: + example.proto + + It has these top-level messages: + A + B + C + U + E + R + CastType +*/ +package test + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test" +import github_com_gogo_protobuf_test_custom "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type A struct { + Description string `protobuf:"bytes,1,opt,name=Description" json:"Description"` + Number int64 `protobuf:"varint,2,opt,name=Number" json:"Number"` + Id github_com_gogo_protobuf_test.Uuid `protobuf:"bytes,3,opt,name=Id,customtype=github.com/gogo/protobuf/test.Uuid" json:"Id"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *A) Reset() { *m = A{} } +func (*A) ProtoMessage() {} + +type B struct { + A `protobuf:"bytes,1,opt,name=A,embedded=A" json:"A"` + G []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=G,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"G"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *B) Reset() { *m = B{} } +func (*B) ProtoMessage() {} + +type C struct { + MySize *int64 `protobuf:"varint,1,opt,name=size" json:"size,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *C) Reset() { *m = C{} } +func (*C) ProtoMessage() {} + +func (m *C) GetMySize() int64 { + if m != nil && m.MySize != nil { + return *m.MySize + } + return 0 +} + +type U struct { + A *A `protobuf:"bytes,1,opt,name=A" json:"A,omitempty"` + B *B `protobuf:"bytes,2,opt,name=B" json:"B,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *U) Reset() { *m = U{} } +func (*U) ProtoMessage() {} + +func (m *U) GetA() *A { + if m != nil { + return m.A + } + return nil +} + +func (m *U) GetB() *B { + if m != nil { + return m.B + } + return nil +} + +type E struct { + XXX_extensions []byte `protobuf:"bytes,0,opt" json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *E) Reset() { *m = E{} } +func (*E) ProtoMessage() {} + +var extRange_E = []proto.ExtensionRange{ + {1, 536870911}, +} + +func (*E) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_E +} +func (m *E) GetExtensions() *[]byte { + if m.XXX_extensions == nil { + m.XXX_extensions = make([]byte, 0) + } + return &m.XXX_extensions +} + +type R struct { + Recognized *uint32 `protobuf:"varint,1,opt,name=recognized" json:"recognized,omitempty"` +} + +func (m *R) Reset() { *m = R{} } +func (*R) ProtoMessage() {} + +func (m *R) GetRecognized() uint32 { + if m != nil && m.Recognized != nil { + return *m.Recognized + } + return 0 +} + +type CastType struct { + Int32 *int32 `protobuf:"varint,1,opt,name=Int32,casttype=int32" json:"Int32,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CastType) Reset() { *m = CastType{} } +func (*CastType) ProtoMessage() {} + +func (m *CastType) GetInt32() int32 { + if m != nil && m.Int32 != nil { + return *m.Int32 + } + return 0 +} + +func (this *B) Description() (desc *google_protobuf.FileDescriptorSet) { + return ExampleDescription() +} +func ExampleDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("example.proto"), + Package: func(v string) *string { return &v }("test"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("A"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Description"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x22, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x55, 0x75, 0x69, 0x64})}}, + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x0}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("B"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.A"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("G"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64014: proto.NewExtension([]byte{0xf0, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("C"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("size"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x4d, 0x79, 0x53, 0x69, 0x7a, 0x65})}}, + }}, + }, {Name: func(v string) *string { return &v }("U"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.A"), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.B"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("E"), + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1), + End: func(v int32) *int32 { return &v }(536870912), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64025: proto.NewExtension([]byte{0xc8, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("R"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("recognized"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("CastType"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Int32"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x5, 0x69, 0x6e, 0x74, 0x33, 0x32})}}, + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1})}}, + }}, + } +} +func (this *A) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*A) + if !ok { + return fmt.Errorf("that is not of type *A") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *A but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Abut is not nil && this == nil") + } + if this.Description != that1.Description { + return fmt.Errorf("Description this(%v) Not Equal that(%v)", this.Description, that1.Description) + } + if this.Number != that1.Number { + return fmt.Errorf("Number this(%v) Not Equal that(%v)", this.Number, that1.Number) + } + if !this.Id.Equal(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *A) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*A) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Description != that1.Description { + return false + } + if this.Number != that1.Number { + return false + } + if !this.Id.Equal(that1.Id) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *B) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*B) + if !ok { + return fmt.Errorf("that is not of type *B") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *B but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Bbut is not nil && this == nil") + } + if !this.A.Equal(&that1.A) { + return fmt.Errorf("A this(%v) Not Equal that(%v)", this.A, that1.A) + } + if len(this.G) != len(that1.G) { + return fmt.Errorf("G this(%v) Not Equal that(%v)", len(this.G), len(that1.G)) + } + for i := range this.G { + if !this.G[i].Equal(that1.G[i]) { + return fmt.Errorf("G this[%v](%v) Not Equal that[%v](%v)", i, this.G[i], i, that1.G[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *B) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*B) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.A.Equal(&that1.A) { + return false + } + if len(this.G) != len(that1.G) { + return false + } + for i := range this.G { + if !this.G[i].Equal(that1.G[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *C) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*C) + if !ok { + return fmt.Errorf("that is not of type *C") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *C but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Cbut is not nil && this == nil") + } + if this.MySize != nil && that1.MySize != nil { + if *this.MySize != *that1.MySize { + return fmt.Errorf("MySize this(%v) Not Equal that(%v)", *this.MySize, *that1.MySize) + } + } else if this.MySize != nil { + return fmt.Errorf("this.MySize == nil && that.MySize != nil") + } else if that1.MySize != nil { + return fmt.Errorf("MySize this(%v) Not Equal that(%v)", this.MySize, that1.MySize) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *C) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*C) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.MySize != nil && that1.MySize != nil { + if *this.MySize != *that1.MySize { + return false + } + } else if this.MySize != nil { + return false + } else if that1.MySize != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *U) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*U) + if !ok { + return fmt.Errorf("that is not of type *U") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *U but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Ubut is not nil && this == nil") + } + if !this.A.Equal(that1.A) { + return fmt.Errorf("A this(%v) Not Equal that(%v)", this.A, that1.A) + } + if !this.B.Equal(that1.B) { + return fmt.Errorf("B this(%v) Not Equal that(%v)", this.B, that1.B) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *U) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*U) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.A.Equal(that1.A) { + return false + } + if !this.B.Equal(that1.B) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *E) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*E) + if !ok { + return fmt.Errorf("that is not of type *E") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *E but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Ebut is not nil && this == nil") + } + if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) { + return fmt.Errorf("XXX_extensions this(%v) Not Equal that(%v)", this.XXX_extensions, that1.XXX_extensions) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *E) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*E) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *R) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*R) + if !ok { + return fmt.Errorf("that is not of type *R") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *R but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Rbut is not nil && this == nil") + } + if this.Recognized != nil && that1.Recognized != nil { + if *this.Recognized != *that1.Recognized { + return fmt.Errorf("Recognized this(%v) Not Equal that(%v)", *this.Recognized, *that1.Recognized) + } + } else if this.Recognized != nil { + return fmt.Errorf("this.Recognized == nil && that.Recognized != nil") + } else if that1.Recognized != nil { + return fmt.Errorf("Recognized this(%v) Not Equal that(%v)", this.Recognized, that1.Recognized) + } + return nil +} +func (this *R) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*R) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Recognized != nil && that1.Recognized != nil { + if *this.Recognized != *that1.Recognized { + return false + } + } else if this.Recognized != nil { + return false + } else if that1.Recognized != nil { + return false + } + return true +} +func (this *CastType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CastType) + if !ok { + return fmt.Errorf("that is not of type *CastType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CastType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CastTypebut is not nil && this == nil") + } + if this.Int32 != nil && that1.Int32 != nil { + if *this.Int32 != *that1.Int32 { + return fmt.Errorf("Int32 this(%v) Not Equal that(%v)", *this.Int32, *that1.Int32) + } + } else if this.Int32 != nil { + return fmt.Errorf("this.Int32 == nil && that.Int32 != nil") + } else if that1.Int32 != nil { + return fmt.Errorf("Int32 this(%v) Not Equal that(%v)", this.Int32, that1.Int32) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CastType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CastType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Int32 != nil && that1.Int32 != nil { + if *this.Int32 != *that1.Int32 { + return false + } + } else if this.Int32 != nil { + return false + } else if that1.Int32 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} + +type AFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetDescription() string + GetNumber() int64 + GetId() github_com_gogo_protobuf_test.Uuid +} + +func (this *A) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *A) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAFromFace(this) +} + +func (this *A) GetDescription() string { + return this.Description +} + +func (this *A) GetNumber() int64 { + return this.Number +} + +func (this *A) GetId() github_com_gogo_protobuf_test.Uuid { + return this.Id +} + +func NewAFromFace(that AFace) *A { + this := &A{} + this.Description = that.GetDescription() + this.Number = that.GetNumber() + this.Id = that.GetId() + return this +} + +func (this *A) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.A{") + s = append(s, "Description: "+fmt.Sprintf("%#v", this.Description)+",\n") + s = append(s, "Number: "+fmt.Sprintf("%#v", this.Number)+",\n") + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *B) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.B{") + s = append(s, "A: "+strings.Replace(this.A.GoString(), `&`, ``, 1)+",\n") + if this.G != nil { + s = append(s, "G: "+fmt.Sprintf("%#v", this.G)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *C) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.C{") + if this.MySize != nil { + s = append(s, "MySize: "+valueToGoStringExample(this.MySize, "int64")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *U) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.U{") + if this.A != nil { + s = append(s, "A: "+fmt.Sprintf("%#v", this.A)+",\n") + } + if this.B != nil { + s = append(s, "B: "+fmt.Sprintf("%#v", this.B)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *E) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 4) + s = append(s, "&test.E{") + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+fmt.Sprintf("%#v", this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *R) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.R{") + if this.Recognized != nil { + s = append(s, "Recognized: "+valueToGoStringExample(this.Recognized, "uint32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CastType) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.CastType{") + if this.Int32 != nil { + s = append(s, "Int32: "+valueToGoStringExample(this.Int32, "int32")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringExample(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringExample(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *A) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *A) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintExample(data, i, uint64(len(m.Description))) + i += copy(data[i:], m.Description) + data[i] = 0x10 + i++ + i = encodeVarintExample(data, i, uint64(m.Number)) + data[i] = 0x1a + i++ + i = encodeVarintExample(data, i, uint64(m.Id.Size())) + n1, err := m.Id.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n1 + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *B) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *B) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintExample(data, i, uint64(m.A.Size())) + n2, err := m.A.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + if len(m.G) > 0 { + for _, msg := range m.G { + data[i] = 0x12 + i++ + i = encodeVarintExample(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *C) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *C) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.MySize != nil { + data[i] = 0x8 + i++ + i = encodeVarintExample(data, i, uint64(*m.MySize)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *U) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *U) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.A != nil { + data[i] = 0xa + i++ + i = encodeVarintExample(data, i, uint64(m.A.Size())) + n3, err := m.A.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n3 + } + if m.B != nil { + data[i] = 0x12 + i++ + i = encodeVarintExample(data, i, uint64(m.B.Size())) + n4, err := m.B.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n4 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *E) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *E) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.XXX_extensions != nil { + i += copy(data[i:], m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *R) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *R) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Recognized != nil { + data[i] = 0x8 + i++ + i = encodeVarintExample(data, i, uint64(*m.Recognized)) + } + return i, nil +} + +func (m *CastType) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CastType) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Int32 != nil { + data[i] = 0x8 + i++ + i = encodeVarintExample(data, i, uint64(*m.Int32)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Example(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Example(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintExample(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedA(r randyExample, easy bool) *A { + this := &A{} + this.Description = randStringExample(r) + this.Number = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Number *= -1 + } + v1 := github_com_gogo_protobuf_test.NewPopulatedUuid(r) + this.Id = *v1 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedExample(r, 4) + } + return this +} + +func NewPopulatedB(r randyExample, easy bool) *B { + this := &B{} + v2 := NewPopulatedA(r, easy) + this.A = *v2 + if r.Intn(10) != 0 { + v3 := r.Intn(10) + this.G = make([]github_com_gogo_protobuf_test_custom.Uint128, v3) + for i := 0; i < v3; i++ { + v4 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.G[i] = *v4 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedExample(r, 3) + } + return this +} + +func NewPopulatedC(r randyExample, easy bool) *C { + this := &C{} + if r.Intn(10) != 0 { + v5 := int64(r.Int63()) + if r.Intn(2) == 0 { + v5 *= -1 + } + this.MySize = &v5 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedExample(r, 2) + } + return this +} + +func NewPopulatedU(r randyExample, easy bool) *U { + this := &U{} + fieldNum := r.Intn(2) + switch fieldNum { + case 0: + this.A = NewPopulatedA(r, easy) + case 1: + this.B = NewPopulatedB(r, easy) + } + return this +} + +func NewPopulatedE(r randyExample, easy bool) *E { + this := &E{} + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + fieldNumber := r.Intn(536870911) + 1 + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldExample(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + return this +} + +func NewPopulatedR(r randyExample, easy bool) *R { + this := &R{} + if r.Intn(10) != 0 { + v6 := uint32(r.Uint32()) + this.Recognized = &v6 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedCastType(r randyExample, easy bool) *CastType { + this := &CastType{} + if r.Intn(10) != 0 { + v7 := int32(r.Int63()) + if r.Intn(2) == 0 { + v7 *= -1 + } + this.Int32 = &v7 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedExample(r, 2) + } + return this +} + +type randyExample interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneExample(r randyExample) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringExample(r randyExample) string { + v8 := r.Intn(100) + tmps := make([]rune, v8) + for i := 0; i < v8; i++ { + tmps[i] = randUTF8RuneExample(r) + } + return string(tmps) +} +func randUnrecognizedExample(r randyExample, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldExample(data, r, fieldNumber, wire) + } + return data +} +func randFieldExample(data []byte, r randyExample, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateExample(data, uint64(key)) + v9 := r.Int63() + if r.Intn(2) == 0 { + v9 *= -1 + } + data = encodeVarintPopulateExample(data, uint64(v9)) + case 1: + data = encodeVarintPopulateExample(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateExample(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateExample(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateExample(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateExample(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *A) Size() (n int) { + var l int + _ = l + l = len(m.Description) + n += 1 + l + sovExample(uint64(l)) + n += 1 + sovExample(uint64(m.Number)) + l = m.Id.Size() + n += 1 + l + sovExample(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *B) Size() (n int) { + var l int + _ = l + l = m.A.Size() + n += 1 + l + sovExample(uint64(l)) + if len(m.G) > 0 { + for _, e := range m.G { + l = e.Size() + n += 1 + l + sovExample(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *C) Size() (n int) { + var l int + _ = l + if m.MySize != nil { + n += 1 + sovExample(uint64(*m.MySize)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *U) Size() (n int) { + var l int + _ = l + if m.A != nil { + l = m.A.Size() + n += 1 + l + sovExample(uint64(l)) + } + if m.B != nil { + l = m.B.Size() + n += 1 + l + sovExample(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *E) Size() (n int) { + var l int + _ = l + if m.XXX_extensions != nil { + n += len(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *R) Size() (n int) { + var l int + _ = l + if m.Recognized != nil { + n += 1 + sovExample(uint64(*m.Recognized)) + } + return n +} + +func (m *CastType) Size() (n int) { + var l int + _ = l + if m.Int32 != nil { + n += 1 + sovExample(uint64(*m.Int32)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovExample(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozExample(x uint64) (n int) { + return sovExample(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *A) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&A{`, + `Description:` + fmt.Sprintf("%v", this.Description) + `,`, + `Number:` + fmt.Sprintf("%v", this.Number) + `,`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *B) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&B{`, + `A:` + strings.Replace(strings.Replace(this.A.String(), "A", "A", 1), `&`, ``, 1) + `,`, + `G:` + fmt.Sprintf("%v", this.G) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *C) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&C{`, + `MySize:` + valueToStringExample(this.MySize) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *U) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&U{`, + `A:` + strings.Replace(fmt.Sprintf("%v", this.A), "A", "A", 1) + `,`, + `B:` + strings.Replace(fmt.Sprintf("%v", this.B), "B", "B", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *E) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&E{`, + `XXX_extensions:` + proto.StringFromExtensionsBytes(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *R) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&R{`, + `Recognized:` + valueToStringExample(this.Recognized) + `,`, + `}`, + }, "") + return s +} +func (this *CastType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CastType{`, + `Int32:` + valueToStringExample(this.Int32) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringExample(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (this *U) GetValue() interface{} { + if this.A != nil { + return this.A + } + if this.B != nil { + return this.B + } + return nil +} + +func (this *U) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *A: + this.A = vt + case *B: + this.B = vt + default: + return false + } + return true +} +func (m *A) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: A: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: A: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthExample + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType) + } + m.Number = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Number |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthExample + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Id.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipExample(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthExample + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *B) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: B: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: B: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthExample + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.A.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field G", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthExample + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_gogo_protobuf_test_custom.Uint128 + m.G = append(m.G, v) + if err := m.G[len(m.G)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipExample(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthExample + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *C) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: C: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: C: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MySize", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.MySize = &v + default: + iNdEx = preIndex + skippy, err := skipExample(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthExample + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *U) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: U: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: U: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthExample + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.A == nil { + m.A = &A{} + } + if err := m.A.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthExample + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.B == nil { + m.B = &B{} + } + if err := m.B.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipExample(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthExample + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *E) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: E: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: E: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + if (fieldNum >= 1) && (fieldNum < 536870912) { + var sizeOfWire int + for { + sizeOfWire++ + wire >>= 7 + if wire == 0 { + break + } + } + iNdEx -= sizeOfWire + skippy, err := skipExample(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthExample + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_extensions = append(m.XXX_extensions, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } else { + iNdEx = preIndex + skippy, err := skipExample(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthExample + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *R) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: R: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: R: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Recognized", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Recognized = &v + default: + iNdEx = preIndex + skippy, err := skipExample(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthExample + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CastType) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CastType: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CastType: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowExample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Int32 = &v + default: + iNdEx = preIndex + skippy, err := skipExample(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthExample + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipExample(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowExample + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowExample + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowExample + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthExample + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowExample + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipExample(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthExample = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowExample = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/example/example.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/example/example.proto new file mode 100644 index 0000000000000000000000000000000000000000..b69ea876e572e2df12ebb60a4676bc6209f1ee08 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/example/example.proto @@ -0,0 +1,81 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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"; + +package test; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.gostring_all) = true; +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.stringer_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.testgen_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.unmarshaler_all) = true; + +message A { + option (gogoproto.face) = true; + option (gogoproto.goproto_getters) = false; + optional string Description = 1 [(gogoproto.nullable) = false]; + optional int64 Number = 2 [(gogoproto.nullable) = false]; + optional bytes Id = 3 [(gogoproto.customtype) = "github.com/gogo/protobuf/test.Uuid", (gogoproto.nullable) = false]; +} + +message B { + option (gogoproto.description) = true; + optional A A = 1 [(gogoproto.nullable) = false, (gogoproto.embed) = true]; + repeated bytes G = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; +} + +message C { + optional int64 size = 1 [(gogoproto.customname) = "MySize"]; +} + +message U { + option (gogoproto.onlyone) = true; + optional A A = 1; + optional B B = 2; +} + +message E { + option (gogoproto.goproto_extensions_map) = false; + extensions 1 to max; +} + +message R { + option (gogoproto.goproto_unrecognized) = false; + optional uint32 recognized = 1; +} + +message CastType { + optional int64 Int32 = 1 [(gogoproto.casttype)="int32"]; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/example/example_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/example/example_test.go new file mode 100644 index 0000000000000000000000000000000000000000..79ef9476bb9bd8858085b8872759488369989669 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/example/example_test.go @@ -0,0 +1,35 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 test + +import "testing" + +func TestGetterExists(t *testing.T) { + _ = (&CastType{}).GetInt32() +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/example/examplepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/example/examplepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..3a9b981a2a952abe4789eefd0738d79d89acfa31 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/example/examplepb_test.go @@ -0,0 +1,1673 @@ +// Code generated by protoc-gen-gogo. +// source: example.proto +// DO NOT EDIT! + +/* +Package test is a generated protocol buffer package. + +It is generated from these files: + example.proto + +It has these top-level messages: + A + B + C + U + E + R + CastType +*/ +package test + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestAProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &A{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &A{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*A, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedA(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedA(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &A{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestBProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedB(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &B{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestBMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedB(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &B{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkBProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*B, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedB(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkBProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedB(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &B{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedC(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &C{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedC(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &C{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*C, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedC(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedC(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &C{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedU(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &U{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedU(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &U{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkUProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*U, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedU(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedU(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &U{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestEProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedE(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &E{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestEMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedE(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &E{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkEProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*E, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedE(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkEProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedE(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &E{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestRProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedR(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &R{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestRMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedR(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &R{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkRProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*R, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedR(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkRProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedR(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &R{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCastTypeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastType(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CastType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCastTypeMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastType(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CastType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkCastTypeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CastType, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCastType(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCastTypeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCastType(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CastType{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &A{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestBJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedB(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &B{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedC(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &C{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedU(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &U{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestEJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedE(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &E{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestRJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedR(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &R{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCastTypeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastType(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CastType{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &A{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &A{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestBProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedB(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &B{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestBProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedB(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &B{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedC(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &C{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedC(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &C{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedU(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &U{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedU(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &U{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestEProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedE(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &E{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestEProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedE(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &E{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestRProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedR(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &R{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestRProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedR(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &R{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCastTypeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastType(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CastType{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCastTypeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastType(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CastType{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestExampleDescription(t *testing.T) { + ExampleDescription() +} +func TestAVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedA(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &A{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestBVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedB(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &B{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedC(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &C{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedU(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &U{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestEVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedE(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &E{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestRVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedR(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &R{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCastTypeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastType(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CastType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedA(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedA(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestBGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedB(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedC(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedU(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestEGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedE(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestRGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedR(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCastTypeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastType(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestASize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkASize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*A, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedA(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestBSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedB(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkBSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*B, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedB(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedC(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*C, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedC(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedU(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*U, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedU(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestESize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedE(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkESize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*E, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedE(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestRSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedR(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkRSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*R, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedR(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCastTypeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCastType(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCastTypeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CastType, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCastType(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedA(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestBStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedB(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedC(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedU(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestEStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedE(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestRStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedR(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCastTypeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCastType(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedU(popr, true) + v := p.GetValue() + msg := &U{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/extension_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/extension_test.go new file mode 100644 index 0000000000000000000000000000000000000000..28cad18acae73aca4b6ac6fb765031684138b038 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/extension_test.go @@ -0,0 +1,162 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 test + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "math" + math_rand "math/rand" + "testing" + "time" +) + +//func SetRawExtension(base extendableProto, id int32, b []byte) { +//func HasExtension(pb extendableProto, extension *ExtensionDesc) bool { +//func ClearExtension(pb extendableProto, extension *ExtensionDesc) { +//func GetExtension(pb extendableProto, extension *ExtensionDesc) (interface{}, error) { +//func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) { +//func SetExtension(pb extendableProto, extension *ExtensionDesc, value interface{}) error { + +type extendable interface { + proto.Message + ExtensionRangeArray() []proto.ExtensionRange +} + +func check(t *testing.T, m extendable, fieldA float64, ext *proto.ExtensionDesc) { + if !proto.HasExtension(m, ext) { + t.Fatalf("expected extension to be set") + } + fieldA2Interface, err := proto.GetExtension(m, ext) + if err != nil { + panic(err) + } + fieldA2 := fieldA2Interface.(*float64) + if fieldA != *fieldA2 { + t.Fatalf("Expected %f got %f", fieldA, *fieldA2) + } + fieldA3Interface, err := proto.GetUnsafeExtension(m, ext.Field) + if err != nil { + panic(err) + } + fieldA3 := fieldA3Interface.(*float64) + if fieldA != *fieldA3 { + t.Fatalf("Expected %f got %f", fieldA, *fieldA3) + } + proto.ClearExtension(m, ext) + if proto.HasExtension(m, ext) { + t.Fatalf("expected extension to be cleared") + } +} + +var fieldA float64 +var fieldABytes []byte +var extr = math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + +func init() { + fieldA = float64(1.1) + fieldABits := math.Float64bits(fieldA) + x := uint64(uint32(100)<<3 | uint32(proto.WireFixed64)) + fieldABytes = encodeVarintPopulateThetest(nil, x) + fieldABytes = append(fieldABytes, uint8(fieldABits)) + fieldABytes = append(fieldABytes, uint8(fieldABits>>8)) + fieldABytes = append(fieldABytes, uint8(fieldABits>>16)) + fieldABytes = append(fieldABytes, uint8(fieldABits>>24)) + fieldABytes = append(fieldABytes, uint8(fieldABits>>32)) + fieldABytes = append(fieldABytes, uint8(fieldABits>>40)) + fieldABytes = append(fieldABytes, uint8(fieldABits>>48)) + fieldABytes = append(fieldABytes, uint8(fieldABits>>56)) +} + +func TestExtensionsMyExtendable(t *testing.T) { + m := NewPopulatedMyExtendable(extr, false) + err := proto.SetExtension(m, E_FieldA, &fieldA) + if err != nil { + panic(err) + } + check(t, m, fieldA, E_FieldA) + proto.SetRawExtension(m, 100, fieldABytes) + check(t, m, fieldA, E_FieldA) +} + +func TestExtensionsNoExtensionsMapSetExtension(t *testing.T) { + m := NewPopulatedNoExtensionsMap(extr, false) + err := proto.SetExtension(m, E_FieldA1, &fieldA) + if err != nil { + panic(err) + } + check(t, m, fieldA, E_FieldA1) +} + +func TestExtensionsNoExtensionsMapSetRawExtension(t *testing.T) { + m := NewPopulatedNoExtensionsMap(extr, false) + proto.SetRawExtension(m, 100, fieldABytes) + check(t, m, fieldA, E_FieldA1) +} + +func TestUnsafeExtension(t *testing.T) { + m := NewPopulatedMyExtendable(extr, false) + err := proto.SetUnsafeExtension(m, E_FieldA.Field, &fieldA) + if err != nil { + panic(err) + } + check(t, m, fieldA, E_FieldA) +} + +//See another version of this test in proto/extensions_test.go +func TestGetExtensionStability(t *testing.T) { + check := func(m *NoExtensionsMap) bool { + ext1, err := proto.GetExtension(m, E_FieldB1) + if err != nil { + t.Fatalf("GetExtension() failed: %s", err) + } + ext2, err := proto.GetExtension(m, E_FieldB1) + if err != nil { + t.Fatalf("GetExtension() failed: %s", err) + } + return ext1.(*NinOptNative).Equal(ext2) + } + msg := &NoExtensionsMap{Field1: proto.Int64(2)} + ext0 := &NinOptNative{Field1: proto.Float64(1)} + if err := proto.SetExtension(msg, E_FieldB1, ext0); err != nil { + t.Fatalf("Could not set ext1: %s", ext0) + } + if !check(msg) { + t.Errorf("GetExtension() not stable before marshaling") + } + bb, err := proto.Marshal(msg) + if err != nil { + t.Fatalf("Marshal() failed: %s", err) + } + msg1 := &NoExtensionsMap{} + err = proto.Unmarshal(bb, msg1) + if err != nil { + t.Fatalf("Unmarshal() failed: %s", err) + } + if !check(msg1) { + t.Errorf("GetExtension() not stable after unmarshaling") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/fuzztests/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/fuzztests/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..2299ee10dfd5c88d6041f2dccf785793eddfb2e9 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/fuzztests/Makefile @@ -0,0 +1,31 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/protobuf/gogoproto +# +# 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. +# +# 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: + go install github.com/gogo/protobuf/protoc-gen-gogofast + protoc --proto_path=../../../../../:../../protobuf/:. --gogofast_out=. fuzz.proto \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/fuzztests/fuzz.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/fuzztests/fuzz.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..e31764fb6cc670cfe4c2d47b2977a848ab3148b9 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/fuzztests/fuzz.pb.go @@ -0,0 +1,2881 @@ +// Code generated by protoc-gen-gogo. +// source: fuzz.proto +// DO NOT EDIT! + +/* + Package fuzztests is a generated protocol buffer package. + + It is generated from these files: + fuzz.proto + + It has these top-level messages: + Nil + NinRepPackedNative + NinOptNative + NinOptStruct +*/ +package fuzztests + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Nil struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *Nil) Reset() { *m = Nil{} } +func (m *Nil) String() string { return proto.CompactTextString(m) } +func (*Nil) ProtoMessage() {} + +type NinRepPackedNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepPackedNative) Reset() { *m = NinRepPackedNative{} } +func (m *NinRepPackedNative) String() string { return proto.CompactTextString(m) } +func (*NinRepPackedNative) ProtoMessage() {} + +func (m *NinRepPackedNative) GetField1() []float64 { + if m != nil { + return m.Field1 + } + return nil +} + +func (m *NinRepPackedNative) GetField2() []float32 { + if m != nil { + return m.Field2 + } + return nil +} + +func (m *NinRepPackedNative) GetField3() []int32 { + if m != nil { + return m.Field3 + } + return nil +} + +func (m *NinRepPackedNative) GetField4() []int64 { + if m != nil { + return m.Field4 + } + return nil +} + +func (m *NinRepPackedNative) GetField5() []uint32 { + if m != nil { + return m.Field5 + } + return nil +} + +func (m *NinRepPackedNative) GetField6() []uint64 { + if m != nil { + return m.Field6 + } + return nil +} + +func (m *NinRepPackedNative) GetField7() []int32 { + if m != nil { + return m.Field7 + } + return nil +} + +func (m *NinRepPackedNative) GetField8() []int64 { + if m != nil { + return m.Field8 + } + return nil +} + +func (m *NinRepPackedNative) GetField9() []uint32 { + if m != nil { + return m.Field9 + } + return nil +} + +func (m *NinRepPackedNative) GetField10() []int32 { + if m != nil { + return m.Field10 + } + return nil +} + +func (m *NinRepPackedNative) GetField11() []uint64 { + if m != nil { + return m.Field11 + } + return nil +} + +func (m *NinRepPackedNative) GetField12() []int64 { + if m != nil { + return m.Field12 + } + return nil +} + +func (m *NinRepPackedNative) GetField13() []bool { + if m != nil { + return m.Field13 + } + return nil +} + +type NinOptNative struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"` + Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"` + Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"` + Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"` + Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNative) Reset() { *m = NinOptNative{} } +func (m *NinOptNative) String() string { return proto.CompactTextString(m) } +func (*NinOptNative) ProtoMessage() {} + +func (m *NinOptNative) GetField1() float64 { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return 0 +} + +func (m *NinOptNative) GetField2() float32 { + if m != nil && m.Field2 != nil { + return *m.Field2 + } + return 0 +} + +func (m *NinOptNative) GetField3() int32 { + if m != nil && m.Field3 != nil { + return *m.Field3 + } + return 0 +} + +func (m *NinOptNative) GetField4() int64 { + if m != nil && m.Field4 != nil { + return *m.Field4 + } + return 0 +} + +func (m *NinOptNative) GetField5() uint32 { + if m != nil && m.Field5 != nil { + return *m.Field5 + } + return 0 +} + +func (m *NinOptNative) GetField6() uint64 { + if m != nil && m.Field6 != nil { + return *m.Field6 + } + return 0 +} + +func (m *NinOptNative) GetField7() int32 { + if m != nil && m.Field7 != nil { + return *m.Field7 + } + return 0 +} + +func (m *NinOptNative) GetField8() int64 { + if m != nil && m.Field8 != nil { + return *m.Field8 + } + return 0 +} + +func (m *NinOptNative) GetField9() uint32 { + if m != nil && m.Field9 != nil { + return *m.Field9 + } + return 0 +} + +func (m *NinOptNative) GetField10() int32 { + if m != nil && m.Field10 != nil { + return *m.Field10 + } + return 0 +} + +func (m *NinOptNative) GetField11() uint64 { + if m != nil && m.Field11 != nil { + return *m.Field11 + } + return 0 +} + +func (m *NinOptNative) GetField12() int64 { + if m != nil && m.Field12 != nil { + return *m.Field12 + } + return 0 +} + +func (m *NinOptNative) GetField13() bool { + if m != nil && m.Field13 != nil { + return *m.Field13 + } + return false +} + +func (m *NinOptNative) GetField14() string { + if m != nil && m.Field14 != nil { + return *m.Field14 + } + return "" +} + +func (m *NinOptNative) GetField15() []byte { + if m != nil { + return m.Field15 + } + return nil +} + +type NinOptStruct struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NinOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field8 *NinOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptStruct) Reset() { *m = NinOptStruct{} } +func (m *NinOptStruct) String() string { return proto.CompactTextString(m) } +func (*NinOptStruct) ProtoMessage() {} + +func (m *NinOptStruct) GetField1() float64 { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return 0 +} + +func (m *NinOptStruct) GetField2() float32 { + if m != nil && m.Field2 != nil { + return *m.Field2 + } + return 0 +} + +func (m *NinOptStruct) GetField3() *NinOptNative { + if m != nil { + return m.Field3 + } + return nil +} + +func (m *NinOptStruct) GetField4() *NinOptNative { + if m != nil { + return m.Field4 + } + return nil +} + +func (m *NinOptStruct) GetField6() uint64 { + if m != nil && m.Field6 != nil { + return *m.Field6 + } + return 0 +} + +func (m *NinOptStruct) GetField7() int32 { + if m != nil && m.Field7 != nil { + return *m.Field7 + } + return 0 +} + +func (m *NinOptStruct) GetField8() *NinOptNative { + if m != nil { + return m.Field8 + } + return nil +} + +func (m *NinOptStruct) GetField13() bool { + if m != nil && m.Field13 != nil { + return *m.Field13 + } + return false +} + +func (m *NinOptStruct) GetField14() string { + if m != nil && m.Field14 != nil { + return *m.Field14 + } + return "" +} + +func (m *NinOptStruct) GetField15() []byte { + if m != nil { + return m.Field15 + } + return nil +} + +func (this *Nil) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 4) + s = append(s, "&fuzztests.Nil{") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepPackedNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 17) + s = append(s, "&fuzztests.NinRepPackedNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&fuzztests.NinOptNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringFuzz(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringFuzz(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringFuzz(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringFuzz(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringFuzz(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringFuzz(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringFuzz(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+valueToGoStringFuzz(this.Field8, "int64")+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+valueToGoStringFuzz(this.Field9, "uint32")+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+valueToGoStringFuzz(this.Field10, "int32")+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+valueToGoStringFuzz(this.Field11, "uint64")+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+valueToGoStringFuzz(this.Field12, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringFuzz(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringFuzz(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringFuzz(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&fuzztests.NinOptStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringFuzz(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringFuzz(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringFuzz(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringFuzz(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringFuzz(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringFuzz(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringFuzz(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringFuzz(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringFuzz(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *Nil) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Nil) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinRepPackedNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinRepPackedNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field1) > 0 { + data[i] = 0xa + i++ + i = encodeVarintFuzz(data, i, uint64(len(m.Field1)*8)) + for _, num := range m.Field1 { + f1 := math.Float64bits(num) + data[i] = uint8(f1) + i++ + data[i] = uint8(f1 >> 8) + i++ + data[i] = uint8(f1 >> 16) + i++ + data[i] = uint8(f1 >> 24) + i++ + data[i] = uint8(f1 >> 32) + i++ + data[i] = uint8(f1 >> 40) + i++ + data[i] = uint8(f1 >> 48) + i++ + data[i] = uint8(f1 >> 56) + i++ + } + } + if len(m.Field2) > 0 { + data[i] = 0x12 + i++ + i = encodeVarintFuzz(data, i, uint64(len(m.Field2)*4)) + for _, num := range m.Field2 { + f2 := math.Float32bits(num) + data[i] = uint8(f2) + i++ + data[i] = uint8(f2 >> 8) + i++ + data[i] = uint8(f2 >> 16) + i++ + data[i] = uint8(f2 >> 24) + i++ + } + } + if len(m.Field3) > 0 { + data4 := make([]byte, len(m.Field3)*10) + var j3 int + for _, num1 := range m.Field3 { + num := uint64(num1) + for num >= 1<<7 { + data4[j3] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j3++ + } + data4[j3] = uint8(num) + j3++ + } + data[i] = 0x1a + i++ + i = encodeVarintFuzz(data, i, uint64(j3)) + i += copy(data[i:], data4[:j3]) + } + if len(m.Field4) > 0 { + data6 := make([]byte, len(m.Field4)*10) + var j5 int + for _, num1 := range m.Field4 { + num := uint64(num1) + for num >= 1<<7 { + data6[j5] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j5++ + } + data6[j5] = uint8(num) + j5++ + } + data[i] = 0x22 + i++ + i = encodeVarintFuzz(data, i, uint64(j5)) + i += copy(data[i:], data6[:j5]) + } + if len(m.Field5) > 0 { + data8 := make([]byte, len(m.Field5)*10) + var j7 int + for _, num := range m.Field5 { + for num >= 1<<7 { + data8[j7] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j7++ + } + data8[j7] = uint8(num) + j7++ + } + data[i] = 0x2a + i++ + i = encodeVarintFuzz(data, i, uint64(j7)) + i += copy(data[i:], data8[:j7]) + } + if len(m.Field6) > 0 { + data10 := make([]byte, len(m.Field6)*10) + var j9 int + for _, num := range m.Field6 { + for num >= 1<<7 { + data10[j9] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j9++ + } + data10[j9] = uint8(num) + j9++ + } + data[i] = 0x32 + i++ + i = encodeVarintFuzz(data, i, uint64(j9)) + i += copy(data[i:], data10[:j9]) + } + if len(m.Field7) > 0 { + data11 := make([]byte, len(m.Field7)*5) + var j12 int + for _, num := range m.Field7 { + x13 := (uint32(num) << 1) ^ uint32((num >> 31)) + for x13 >= 1<<7 { + data11[j12] = uint8(uint64(x13)&0x7f | 0x80) + j12++ + x13 >>= 7 + } + data11[j12] = uint8(x13) + j12++ + } + data[i] = 0x3a + i++ + i = encodeVarintFuzz(data, i, uint64(j12)) + i += copy(data[i:], data11[:j12]) + } + if len(m.Field8) > 0 { + var j14 int + data16 := make([]byte, len(m.Field8)*10) + for _, num := range m.Field8 { + x15 := (uint64(num) << 1) ^ uint64((num >> 63)) + for x15 >= 1<<7 { + data16[j14] = uint8(uint64(x15)&0x7f | 0x80) + j14++ + x15 >>= 7 + } + data16[j14] = uint8(x15) + j14++ + } + data[i] = 0x42 + i++ + i = encodeVarintFuzz(data, i, uint64(j14)) + i += copy(data[i:], data16[:j14]) + } + if len(m.Field9) > 0 { + data[i] = 0x4a + i++ + i = encodeVarintFuzz(data, i, uint64(len(m.Field9)*4)) + for _, num := range m.Field9 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field10) > 0 { + data[i] = 0x52 + i++ + i = encodeVarintFuzz(data, i, uint64(len(m.Field10)*4)) + for _, num := range m.Field10 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + } + } + if len(m.Field11) > 0 { + data[i] = 0x5a + i++ + i = encodeVarintFuzz(data, i, uint64(len(m.Field11)*8)) + for _, num := range m.Field11 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field12) > 0 { + data[i] = 0x62 + i++ + i = encodeVarintFuzz(data, i, uint64(len(m.Field12)*8)) + for _, num := range m.Field12 { + data[i] = uint8(num) + i++ + data[i] = uint8(num >> 8) + i++ + data[i] = uint8(num >> 16) + i++ + data[i] = uint8(num >> 24) + i++ + data[i] = uint8(num >> 32) + i++ + data[i] = uint8(num >> 40) + i++ + data[i] = uint8(num >> 48) + i++ + data[i] = uint8(num >> 56) + i++ + } + } + if len(m.Field13) > 0 { + data[i] = 0x6a + i++ + i = encodeVarintFuzz(data, i, uint64(len(m.Field13))) + for _, b := range m.Field13 { + if b { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Fuzz(data, i, uint64(math.Float64bits(*m.Field1))) + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + i = encodeFixed32Fuzz(data, i, uint32(math.Float32bits(*m.Field2))) + } + if m.Field3 != nil { + data[i] = 0x18 + i++ + i = encodeVarintFuzz(data, i, uint64(*m.Field3)) + } + if m.Field4 != nil { + data[i] = 0x20 + i++ + i = encodeVarintFuzz(data, i, uint64(*m.Field4)) + } + if m.Field5 != nil { + data[i] = 0x28 + i++ + i = encodeVarintFuzz(data, i, uint64(*m.Field5)) + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintFuzz(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintFuzz(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field8 != nil { + data[i] = 0x40 + i++ + i = encodeVarintFuzz(data, i, uint64((uint64(*m.Field8)<<1)^uint64((*m.Field8>>63)))) + } + if m.Field9 != nil { + data[i] = 0x4d + i++ + i = encodeFixed32Fuzz(data, i, uint32(*m.Field9)) + } + if m.Field10 != nil { + data[i] = 0x55 + i++ + i = encodeFixed32Fuzz(data, i, uint32(*m.Field10)) + } + if m.Field11 != nil { + data[i] = 0x59 + i++ + i = encodeFixed64Fuzz(data, i, uint64(*m.Field11)) + } + if m.Field12 != nil { + data[i] = 0x61 + i++ + i = encodeFixed64Fuzz(data, i, uint64(*m.Field12)) + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintFuzz(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintFuzz(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptStruct) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptStruct) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Fuzz(data, i, uint64(math.Float64bits(*m.Field1))) + } + if m.Field2 != nil { + data[i] = 0x15 + i++ + i = encodeFixed32Fuzz(data, i, uint32(math.Float32bits(*m.Field2))) + } + if m.Field3 != nil { + data[i] = 0x1a + i++ + i = encodeVarintFuzz(data, i, uint64(m.Field3.Size())) + n17, err := m.Field3.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n17 + } + if m.Field4 != nil { + data[i] = 0x22 + i++ + i = encodeVarintFuzz(data, i, uint64(m.Field4.Size())) + n18, err := m.Field4.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n18 + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintFuzz(data, i, uint64(*m.Field6)) + } + if m.Field7 != nil { + data[i] = 0x38 + i++ + i = encodeVarintFuzz(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field8 != nil { + data[i] = 0x42 + i++ + i = encodeVarintFuzz(data, i, uint64(m.Field8.Size())) + n19, err := m.Field8.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n19 + } + if m.Field13 != nil { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 != nil { + data[i] = 0x72 + i++ + i = encodeVarintFuzz(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintFuzz(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Fuzz(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Fuzz(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintFuzz(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *Nil) Size() (n int) { + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepPackedNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 1 + sovFuzz(uint64(len(m.Field1)*8)) + len(m.Field1)*8 + } + if len(m.Field2) > 0 { + n += 1 + sovFuzz(uint64(len(m.Field2)*4)) + len(m.Field2)*4 + } + if len(m.Field3) > 0 { + l = 0 + for _, e := range m.Field3 { + l += sovFuzz(uint64(e)) + } + n += 1 + sovFuzz(uint64(l)) + l + } + if len(m.Field4) > 0 { + l = 0 + for _, e := range m.Field4 { + l += sovFuzz(uint64(e)) + } + n += 1 + sovFuzz(uint64(l)) + l + } + if len(m.Field5) > 0 { + l = 0 + for _, e := range m.Field5 { + l += sovFuzz(uint64(e)) + } + n += 1 + sovFuzz(uint64(l)) + l + } + if len(m.Field6) > 0 { + l = 0 + for _, e := range m.Field6 { + l += sovFuzz(uint64(e)) + } + n += 1 + sovFuzz(uint64(l)) + l + } + if len(m.Field7) > 0 { + l = 0 + for _, e := range m.Field7 { + l += sozFuzz(uint64(e)) + } + n += 1 + sovFuzz(uint64(l)) + l + } + if len(m.Field8) > 0 { + l = 0 + for _, e := range m.Field8 { + l += sozFuzz(uint64(e)) + } + n += 1 + sovFuzz(uint64(l)) + l + } + if len(m.Field9) > 0 { + n += 1 + sovFuzz(uint64(len(m.Field9)*4)) + len(m.Field9)*4 + } + if len(m.Field10) > 0 { + n += 1 + sovFuzz(uint64(len(m.Field10)*4)) + len(m.Field10)*4 + } + if len(m.Field11) > 0 { + n += 1 + sovFuzz(uint64(len(m.Field11)*8)) + len(m.Field11)*8 + } + if len(m.Field12) > 0 { + n += 1 + sovFuzz(uint64(len(m.Field12)*8)) + len(m.Field12)*8 + } + if len(m.Field13) > 0 { + n += 1 + sovFuzz(uint64(len(m.Field13))) + len(m.Field13)*1 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNative) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovFuzz(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovFuzz(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovFuzz(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovFuzz(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozFuzz(uint64(*m.Field7)) + } + if m.Field8 != nil { + n += 1 + sozFuzz(uint64(*m.Field8)) + } + if m.Field9 != nil { + n += 5 + } + if m.Field10 != nil { + n += 5 + } + if m.Field11 != nil { + n += 9 + } + if m.Field12 != nil { + n += 9 + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovFuzz(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovFuzz(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptStruct) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovFuzz(uint64(l)) + } + if m.Field4 != nil { + l = m.Field4.Size() + n += 1 + l + sovFuzz(uint64(l)) + } + if m.Field6 != nil { + n += 1 + sovFuzz(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozFuzz(uint64(*m.Field7)) + } + if m.Field8 != nil { + l = m.Field8.Size() + n += 1 + l + sovFuzz(uint64(l)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovFuzz(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovFuzz(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovFuzz(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozFuzz(x uint64) (n int) { + return sovFuzz(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Nil) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Nil: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Nil: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipFuzz(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFuzz + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepPackedNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepPackedNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepPackedNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + } + } else if wireType == 1 { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + case 2: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + } + } else if wireType == 5 { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + case 3: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + case 4: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } + } else if wireType == 0 { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + case 5: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } + } else if wireType == 0 { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + case 6: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + case 7: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + case 8: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + case 9: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = append(m.Field9, v) + } + } else if wireType == 5 { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = append(m.Field9, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + case 10: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = append(m.Field10, v) + } + } else if wireType == 5 { + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = append(m.Field10, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + case 11: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = append(m.Field11, v) + } + } else if wireType == 1 { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = append(m.Field11, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + case 12: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = append(m.Field12, v) + } + } else if wireType == 1 { + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = append(m.Field12, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + case 13: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } + } else if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipFuzz(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFuzz + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = &v2 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = &v2 + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = &v + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = &v + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = &v + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + v2 := int64(v) + m.Field8 = &v2 + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = &v + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = &v + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = &v + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = &v + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFuzz(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFuzz + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptStruct) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptStruct: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptStruct: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = &v2 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = &v2 + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field3 == nil { + m.Field3 = &NinOptNative{} + } + if err := m.Field3.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field4 == nil { + m.Field4 = &NinOptNative{} + } + if err := m.Field4.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Field8 == nil { + m.Field8 = &NinOptNative{} + } + if err := m.Field8.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFuzz + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthFuzz + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFuzz(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFuzz + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipFuzz(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFuzz + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFuzz + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFuzz + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthFuzz + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFuzz + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipFuzz(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthFuzz = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowFuzz = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/fuzztests/fuzz.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/fuzztests/fuzz.proto new file mode 100644 index 0000000000000000000000000000000000000000..9002ab71257436c8924710852c2d70441ca54365 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/fuzztests/fuzz.proto @@ -0,0 +1,84 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package fuzztests; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.gostring_all) = true; + +message Nil { + +} + +message NinRepPackedNative { + repeated double Field1 = 1 [packed = true]; + repeated float Field2 = 2 [packed = true]; + repeated int32 Field3 = 3 [packed = true]; + repeated int64 Field4 = 4 [packed = true]; + repeated uint32 Field5 = 5 [packed = true]; + repeated uint64 Field6 = 6 [packed = true]; + repeated sint32 Field7 = 7 [packed = true]; + repeated sint64 Field8 = 8 [packed = true]; + repeated fixed32 Field9 = 9 [packed = true]; + repeated sfixed32 Field10 = 10 [packed = true]; + repeated fixed64 Field11 = 11 [packed = true]; + repeated sfixed64 Field12 = 12 [packed = true]; + repeated bool Field13 = 13 [packed = true]; +} + +message NinOptNative { + optional double Field1 = 1; + optional float Field2 = 2; + optional int32 Field3 = 3; + optional int64 Field4 = 4; + optional uint32 Field5 = 5; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional sint64 Field8 = 8; + optional fixed32 Field9 = 9; + optional sfixed32 Field10 = 10; + optional fixed64 Field11 = 11; + optional sfixed64 Field12 = 12; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NinOptStruct { + optional double Field1 = 1; + optional float Field2 = 2; + optional NinOptNative Field3 = 3; + optional NinOptNative Field4 = 4; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional NinOptNative Field8 = 8; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/fuzztests/fuzz_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/fuzztests/fuzz_test.go new file mode 100644 index 0000000000000000000000000000000000000000..ba5e478f8cb6ca762f35019670fc2e3bae5091c5 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/fuzztests/fuzz_test.go @@ -0,0 +1,134 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 fuzztests + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "testing" +) + +func TestFuzzUnrecognized(t *testing.T) { + msg := &Nil{} + input := []byte{0x8, 0xaf, 0x81, 0xc9, 0xb3, 0x97, 0xd1, 0xb5, 0xc2, 0x4f, 0x1a, 0x4a, 0x52, 0x48, 0x4e, 0x44, 0x65, 0x51, 0x4b, 0x46, 0x44, 0x33, 0x5a, 0x44, 0x72, 0x38, 0x58, 0x4c, 0x58, 0x70, 0x59, 0x45, 0x71, 0x45, 0x4f, 0x6d, 0x45, 0x4d, 0x54, 0x59, 0x4c, 0x6b, 0x55, 0x7a, 0x6f, 0x6b, 0x5a, 0x69, 0x56, 0x64, 0x46, 0x45, 0x56, 0x4d, 0x70, 0x6a, 0x39, 0x7a, 0x4b, 0x43, 0x4d, 0x6d, 0x76, 0x63, 0x46, 0x4f, 0x31, 0x4a, 0x5a, 0x6b, 0x66, 0x4a, 0x75, 0x51, 0x38, 0x54, 0x54, 0x30, 0x53, 0x61, 0x36, 0x6e, 0x4f, 0x6b, 0x35, 0x54, 0x95, 0x0, 0x0, 0x0, 0x0, 0x12, 0x38, 0x52, 0x36, 0x66, 0x76, 0x41, 0x74, 0x73, 0x7a, 0x39, 0x43, 0x6a, 0x4f, 0x64, 0x59, 0x77, 0x33, 0x30, 0x36, 0x58, 0x75, 0x65, 0x46, 0x4b, 0x46, 0x55, 0x56, 0x71, 0x6d, 0x49, 0x73, 0x4a, 0x4b, 0x78, 0x76, 0x41, 0x65, 0x42, 0x61, 0x5a, 0x30, 0x41, 0x37, 0x45, 0x76, 0x72, 0x31, 0x30, 0x4e, 0x78, 0x6d, 0x33, 0x63, 0x65, 0x66, 0x6b, 0x30} + if err := proto.Unmarshal(input, msg); err == nil { + t.Fatal("expected error") + } +} + +func DisabledTestFuzzPackedIsNotIdempotent(t *testing.T) { + msg := &NinRepPackedNative{} + //original := []byte{0x9, 0xa3, 0xae, 0xab, 0xd2, 0xbe, 0x1c, 0xed, 0xbf, 0x15, 0x22, 0x1, 0x6e, 0x3f, 0x22, 0x81, 0x1, 0x9, 0x21, 0x84, 0x36, 0x21, 0x6a, 0xff, 0xd3, 0x3f, 0x15, 0x15, 0x71, 0x4b, 0xbd, 0x52, 0x70, 0x49, 0x6e, 0x48, 0x54, 0x6a, 0x61, 0x37, 0x63, 0x78, 0x47, 0x58, 0x31, 0x7a, 0x43, 0x4d, 0x7a, 0x48, 0x58, 0x56, 0xcb, 0x9c, 0x34, 0xdf, 0xc6, 0x3c, 0xa4, 0x33, 0xac, 0xba, 0xa7, 0xeb, 0x4, 0xa8, 0x8a, 0x48, 0x75, 0x67, 0x71, 0x31, 0x4a, 0x5b, 0xe1, 0xcf, 0x21, 0x88, 0xd3, 0xec, 0xac, 0x13, 0x28, 0xec, 0xa9, 0x51, 0xc8, 0xe9, 0x5e, 0xca, 0xbe, 0xea, 0x9c, 0x0, 0x6b, 0x44, 0x63, 0xc4, 0x32, 0xaa, 0x36, 0x4e, 0xfc, 0xbd, 0x7, 0xef, 0x5e, 0x47, 0x2, 0xfc, 0xd8, 0x83, 0x85, 0x9c, 0xca, 0x7c, 0xd2, 0xdb, 0xf5, 0x5d, 0xcc, 0x5a, 0x72, 0x1f, 0x66, 0x55, 0x74, 0x46, 0x47, 0x73, 0x75, 0x54, 0x30, 0x39, 0x53, 0x34, 0x4c, 0x61, 0x78, 0x59, 0x31, 0x51, 0x44, 0x30, 0x53, 0x51, 0x71, 0x44, 0x65, 0x6f, 0x53, 0x30, 0x44, 0x6a, 0x58, 0x7a, 0x1b, 0x65, 0x62, 0x9c, 0x95, 0xc5, 0x41, 0xcb, 0x48, 0xa, 0x47, 0xf6, 0xd8, 0xd2, 0xd5, 0x8d, 0x6, 0x69, 0x8f, 0xbe, 0x7c, 0xf3, 0xe9, 0x79, 0x3c, 0xca, 0x6, 0x5b} + input := []byte{0x9, 0xa3, 0xae, 0xab, 0xd2, 0xbe, 0x1c, 0xed, 0xbf, 0x15, 0x22, 0x1, 0x6e, 0x3f, 0x22, 0x81, 0x1, 0x9, 0x21, 0x84, 0x36, 0x21, 0x6a, 0xff, 0xd3, 0x3f, 0x15, 0x15, 0x71, 0x4b, 0xbd, 0x52, 0x70, 0x49, 0x6e, 0x48, 0x54, 0x6a, 0x61, 0x37, 0x63, 0x78, 0x47, 0x58, 0x31, 0x7a, 0x43, 0x4d, 0x7a, 0x48, 0x58, 0x56, 0xcb, 0x9c, 0x34, 0xdf, 0xc6, 0x3c, 0xa4, 0x33, 0xac, 0xba, 0xa7, 0xeb, 0x4, 0xa8, 0x8a, 0x48, 0x75, 0x67, 0x71, 0x31, 0x4a, 0x5b, 0xe1, 0xcf, 0x21, 0x88, 0xd3, 0xec, 0xac, 0x13, 0x28, 0xec, 0xa9, 0x51, 0xc8, 0xe9, 0x5e, 0xca, 0xbe, 0xea, 0x9c, 0x0, 0x6b, 0x44, 0x63, 0xc4, 0x32, 0xaa, 0x36, 0x4e, 0xfc, 0xbd, 0x7, 0xef, 0x5e, 0x47, 0x2, 0xfc, 0xd8, 0x83, 0x85, 0x9c, 0xca, 0x7c, 0xd2, 0xdb, 0xf5, 0x5d, 0xcc, 0x5a, 0x72, 0x1f, 0x66, 0x55, 0x74, 0x46, 0x47, 0x73, 0x75, 0x54, 0x30, 0x39, 0x53, 0x34, 0x4c, 0x61, 0x78, 0x59, 0x31, 0x51, 0x44, 0x30, 0x53, 0x51} + if err := proto.Unmarshal(input, msg); err == nil { + t.Fatal("expected error") + } +} + +func DisabledTestFuzzFieldOrder(t *testing.T) { + msg := &NinOptStruct{} + input := []byte{0x52, 0x57, 0x52, 0x6a, 0x33, 0x56, 0x43, 0x76, 0x32, 0x54, 0x49, 0x4a, 0x55, 0x66, 0x39, 0x52, 0x32, 0x32, 0x73, 0x69, 0x4f, 0x67, 0x66, 0x79, 0x4b, 0x79, 0x5a, 0x55, 0x42, 0x53, 0x38, 0x68, 0x6c, 0x46, 0x79, 0x6b, 0x54, 0x43, 0x63, 0x66, 0x30, 0x6a, 0x33, 0x35, 0x33, 0x7a, 0x41, 0x66, 0x68, 0x57, 0x61, 0x78, 0x51, 0x37, 0x76, 0x52, 0x78, 0x34, 0x56, 0x43, 0x54, 0x31, 0x73, 0x6a, 0x77, 0x63, 0x45, 0x62, 0x62, 0x67, 0x34, 0x6f, 0x64, 0x35, 0x6c, 0x41, 0x45, 0x50, 0x64, 0x6f, 0x46, 0x38, 0x41, 0x4b, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30} + if err := proto.Unmarshal(input, msg); err != nil { + t.Fatal(err) + } +} + +func TestFuzzSint64Overflow(t *testing.T) { + msg := &NinOptNative{} + //original := []byte{0x9, 0x65, 0xb4, 0xfd, 0xbc, 0x5, 0xc7, 0xee, 0x3f, 0x15, 0x48, 0xec, 0x67, 0x3f, 0x18, 0xca, 0xa4, 0xe0, 0xa9, 0x5, 0x20, 0x8e, 0xb7, 0x9f, 0xf5, 0xcf, 0xe9, 0xea, 0xad, 0xfd, 0x1, 0x28, 0xc9, 0xf1, 0xbc, 0x88, 0xc, 0x30, 0xeb, 0x99, 0xbd, 0xa8, 0xe, 0x38, 0xc0, 0xd4, 0xb7, 0xba, 0x7, 0x40, 0xc8, 0xe4, 0xf6, 0xe2, 0xb8, 0xdd, 0xa7, 0xf2, 0x82, 0xba, 0x16, 0x9d, 0x59, 0xf9, 0x31, 0xe0, 0x99, 0x0, 0x0, 0x0, 0x0, 0x61, 0x59, 0x5b, 0xb5, 0x57, 0x56, 0x93, 0x70, 0xde, 0x68, 0x0, 0x72, 0x40, 0x64, 0x5a, 0x5a, 0x61, 0x57, 0x78, 0x68, 0x53, 0x65, 0x66, 0x67, 0x38, 0x38, 0x61, 0x48, 0x44, 0x32, 0x6c, 0x36, 0x50, 0x31, 0x4d, 0x43, 0x39, 0x31, 0x6d, 0x37, 0x34, 0x32, 0x48, 0x6b, 0x4d, 0x70, 0x31, 0x45, 0x73, 0x48, 0x71, 0x4a, 0x69, 0x37, 0x56, 0x53, 0x44, 0x6b, 0x48, 0x45, 0x50, 0x4b, 0x7a, 0x52, 0x49, 0x4c, 0x50, 0x69, 0x44, 0x72, 0x42, 0x56, 0x50, 0x78, 0x62, 0x56, 0x55, 0x7a, 0x5b, 0xb3, 0x6c, 0x59, 0x4c, 0xf1, 0x31, 0xeb, 0xb6, 0x25, 0x1a, 0x26, 0x67, 0x66, 0x97, 0x79, 0xb8, 0x37, 0x8, 0xe1, 0x32, 0x45, 0x6e, 0x6, 0x90, 0x4f, 0xde, 0x26, 0x7a, 0xc6, 0x29, 0x65, 0x4a, 0x69, 0xa7, 0x21, 0xfb, 0x42, 0xda, 0x43, 0x89, 0x27, 0x70, 0x71, 0xde, 0x66, 0xa4, 0x75, 0x2b, 0x5c, 0x96, 0x9f, 0x25, 0x3b, 0xc1, 0x64, 0x14, 0x4, 0x60, 0x8c, 0x58, 0x7e, 0xa1, 0x59, 0x7b, 0x47, 0x18, 0xc, 0x5b, 0x18, 0x63, 0x9, 0xb4, 0xc9, 0x7, 0xf9, 0xae, 0x33, 0xae, 0x2, 0x4a, 0x8b, 0x34, 0x92, 0x40, 0xb, 0xd7, 0x80, 0x60, 0xdb, 0x44, 0x5} + input := []byte{0x40, 0xc8, 0xe4, 0xf6, 0xe2, 0xb8, 0xdd, 0xa7, 0xf2, 0x82, 0xba, 0x16} + if err := proto.Unmarshal(input, msg); err != nil { + return + } +} + +func DisabledTestFuzzOverrideField(t *testing.T) { + msg := &NinOptNative{} + //original := []byte{0x9, 0x73, 0x78, 0x5a, 0xf2, 0xb4, 0x66, 0xe8, 0x3f, 0x15, 0x71, 0xdc, 0x4, 0x3f, 0x18, 0xe5, 0x8e, 0xab, 0xdb, 0x3, 0x20, 0xbe, 0xed, 0xe6, 0xc0, 0xb9, 0xb8, 0xa7, 0xb5, 0x12, 0x28, 0xcb, 0x8c, 0x91, 0xef, 0xc, 0x30, 0x9a, 0xc1, 0xc3, 0xc0, 0xf, 0x38, 0xe8, 0x9b, 0xf0, 0xca, 0x5, 0x40, 0xd2, 0xd7, 0xdd, 0xa3, 0xea, 0xab, 0xec, 0xc2, 0xaa, 0x1, 0x4d, 0xc9, 0x15, 0x0, 0xea, 0x55, 0x72, 0x3e, 0x92, 0xa8, 0x59, 0x3e, 0x87, 0x7d, 0xf5, 0x0, 0x0, 0x0, 0x0, 0x61, 0xca, 0xe7, 0xdb, 0x57, 0xa1, 0xb6, 0x41, 0xf4, 0x72, 0x3e, 0x63, 0x36, 0x43, 0x73, 0x32, 0x68, 0x64, 0x75, 0x75, 0x70, 0x4f, 0x39, 0x67, 0x77, 0x42, 0x6a, 0x78, 0x63, 0x57, 0x64, 0x77, 0x6b, 0x74, 0x44, 0x4d, 0x79, 0x36, 0x30, 0x68, 0x38, 0x53, 0x31, 0x79, 0x33, 0x38, 0x4b, 0x7a, 0x76, 0x36, 0x48, 0x4a, 0x35, 0x37, 0x59, 0x48, 0x6c, 0x74, 0x72, 0x61, 0x33, 0x4c, 0x74, 0x45, 0x4a, 0x51, 0x68, 0x71, 0x31, 0x70, 0x50, 0x70, 0x6a, 0x4d, 0x15, 0x51, 0xce, 0xea, 0x82, 0x1, 0x23, 0xed, 0x7a, 0x3, 0x78, 0xee, 0x56, 0x46, 0xd0, 0xe1, 0x17, 0x18, 0x30, 0x9d, 0x2f, 0xac, 0x1c, 0xa, 0x30, 0xa9, 0x8d, 0x10, 0xed, 0xb5, 0x44, 0x36, 0x5e, 0x84, 0x73, 0x5d, 0x38, 0x51, 0x2b, 0x6e, 0xc6, 0xb5} + input := []byte{0x4d, 0xc9, 0x15, 0x0, 0xea, 0x72, 0x3e, 0x63, 0x36, 0x43, 0x73, 0x32, 0x68, 0x64, 0x75, 0x75, 0x70, 0x4f, 0x39, 0x67, 0x77, 0x42, 0x6a, 0x78, 0x63, 0x57, 0x64, 0x77, 0x6b, 0x74, 0x44, 0x4d, 0x79, 0x36, 0x30, 0x68, 0x38, 0x53, 0x31, 0x79, 0x33, 0x38, 0x4b, 0x7a, 0x76, 0x36, 0x48, 0x4a, 0x35, 0x37, 0x59, 0x48, 0x6c, 0x74, 0x72, 0x61, 0x33, 0x4c, 0x74, 0x45, 0x4a, 0x51, 0x68, 0x71, 0x31, 0x70, 0x50, 0x70, 0x6a, 0x4d, 0x15, 0x51, 0xce, 0xea} + if err := proto.Unmarshal(input, msg); err != nil { + panic(err) + } + output, err := proto.Marshal(msg) + if err != nil { + t.Fatal(err) + } + if len(input) != len(output) { + t.Logf("%#v", msg) + msg2 := &NinOptNative{} + if err := proto.Unmarshal(output, msg2); err == nil { + t.Logf("%#v", msg2) + } + t.Errorf("expected %#v got %#v", input, output) + } +} + +//Generated code is correct, non generated returns an incorrect error +func DisabledTestFuzzBadWireType(t *testing.T) { + msg := &NinRepPackedNative{} + //input := []byte("j\x160\xfc0000\xf6\xfa000\xc1\xaf\xf5000\xcf" + "00\xb90z\r0\x850\xd30000'0000") + input := []byte{0x6a, 0x16, 0x30, 0xfc, 0x30, 0x30, 0x30, 0x30, 0xf6, 0xfa, 0x30, 0x30, 0x30, 0xc1, 0xaf, 0xf5, 0x30, 0x30, 0x30, 0xcf, 0x30, 0x30, 0xb9, 0x30, 0x7a, 0xd, 0x30, 0x85, 0x30, 0xd3, 0x30, 0x30, 0x30, 0x30, 0x27, 0x30, 0x30, 0x30, 0x30} + if err := proto.Unmarshal(input, msg); err == nil { + t.Fatalf("expected bad wiretype for Field4 error got %#v", msg) + } else { + t.Log(err) + } +} + +func TestFuzzIntegerOverflow(t *testing.T) { + msg := &Nil{} + //input := []byte("\x1500000\x8b\x9b\xa3\xa8\xb6\xe1\xe1\xfe\u061c0") + input := []byte{0x15, 0x30, 0x30, 0x30, 0x30, 0x30, 0x8b, 0x9b, 0xa3, 0xa8, 0xb6, 0xe1, 0xe1, 0xfe, 0xd8, 0x9c, 0x30} + if err := proto.Unmarshal(input, msg); err == nil { + t.Fatalf("expected integer overflow error %#v", msg) + } else { + t.Log(err) + } +} + +//Generated code is correct, non generated returns an incorrect error +func DisabledTestFuzzUnexpectedEOF(t *testing.T) { + msg := &NinRepPackedNative{} + //input := []byte("j\x16000000000000000000" + "00\xb90") + input := []byte{0x6a, 0x16, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0xb9, 0x30} + if err := proto.Unmarshal(input, msg); err == nil { + t.Fatalf("expected unexpected eof error got %#v", msg) + } else { + t.Log(err) + } +} + +//Generated code is correct, non generated returns an incorrect error +func DisabledTestFuzzCantSkipWireType(t *testing.T) { + msg := &NinRepPackedNative{} + //input := []byte("j\x160\xfc0000\xf6\xfa000\xc1\xaf\xf5000\xcf" + "00\xb90z\r0\x850\xd3000\xa80\xa7000") + input := []byte{0x6a, 0x16, 0x30, 0xfc, 0x30, 0x30, 0x30, 0x30, 0xf6, 0xfa, 0x30, 0x30, 0x30, 0xc1, 0xaf, 0xf5, 0x30, 0x30, 0x30, 0xcf, 0x30, 0x30, 0xb9, 0x30, 0x7a, 0xd, 0x30, 0x85, 0x30, 0xd3, 0x30, 0x30, 0x30, 0xa8, 0x30, 0xa7, 0x30, 0x30, 0x30} + if err := proto.Unmarshal(input, msg); err == nil { + t.Fatalf("expected cant skip wiretype error got %#v", msg) + } else { + t.Log(err) + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/group/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/group/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..f2cc2bdfcde633fd2085eb683657c901999d3247 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/group/Makefile @@ -0,0 +1,30 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. group.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/group/group.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/group/group.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..d17634131cba64c948ec792f67da4632c78fcb2b --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/group/group.pb.go @@ -0,0 +1,2171 @@ +// Code generated by protoc-gen-gogo. +// source: group.proto +// DO NOT EDIT! + +/* +Package group is a generated protocol buffer package. + +It is generated from these files: + group.proto + +It has these top-level messages: + Groups1 + Groups2 +*/ +package group + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Groups1 struct { + G []*Groups1_G `protobuf:"group,1,rep,name=G" json:"g,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Groups1) Reset() { *m = Groups1{} } +func (*Groups1) ProtoMessage() {} + +type Groups1_G struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float64 `protobuf:"fixed64,2,opt,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Groups1_G) Reset() { *m = Groups1_G{} } +func (*Groups1_G) ProtoMessage() {} + +type Groups2 struct { + G *Groups2_G `protobuf:"group,1,opt,name=G" json:"g,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Groups2) Reset() { *m = Groups2{} } +func (*Groups2) ProtoMessage() {} + +type Groups2_G struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 []float64 `protobuf:"fixed64,2,rep,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Groups2_G) Reset() { *m = Groups2_G{} } +func (*Groups2_G) ProtoMessage() {} + +func (this *Groups1) Description() (desc *google_protobuf.FileDescriptorSet) { + return GroupDescription() +} +func (this *Groups1_G) Description() (desc *google_protobuf.FileDescriptorSet) { + return GroupDescription() +} +func (this *Groups2) Description() (desc *google_protobuf.FileDescriptorSet) { + return GroupDescription() +} +func (this *Groups2_G) Description() (desc *google_protobuf.FileDescriptorSet) { + return GroupDescription() +} +func GroupDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("group.proto"), + Package: func(v string) *string { return &v }("group"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Groups1"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("g"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(10), + TypeName: func(v string) *string { return &v }(".group.Groups1.G"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("G"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }}, + }, {Name: func(v string) *string { return &v }("Groups2"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("g"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(10), + TypeName: func(v string) *string { return &v }(".group.Groups2.G"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("G"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x0})}}, + }}, + } +} +func (this *Groups1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Groups1) + if !ok { + return fmt.Errorf("that is not of type *Groups1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Groups1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Groups1but is not nil && this == nil") + } + if len(this.G) != len(that1.G) { + return fmt.Errorf("G this(%v) Not Equal that(%v)", len(this.G), len(that1.G)) + } + for i := range this.G { + if !this.G[i].Equal(that1.G[i]) { + return fmt.Errorf("G this[%v](%v) Not Equal that[%v](%v)", i, this.G[i], i, that1.G[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Groups1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Groups1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.G) != len(that1.G) { + return false + } + for i := range this.G { + if !this.G[i].Equal(that1.G[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Groups1_G) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Groups1_G) + if !ok { + return fmt.Errorf("that is not of type *Groups1_G") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Groups1_G but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Groups1_Gbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Groups1_G) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Groups1_G) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Groups2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Groups2) + if !ok { + return fmt.Errorf("that is not of type *Groups2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Groups2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Groups2but is not nil && this == nil") + } + if !this.G.Equal(that1.G) { + return fmt.Errorf("G this(%v) Not Equal that(%v)", this.G, that1.G) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Groups2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Groups2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.G.Equal(that1.G) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Groups2_G) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Groups2_G) + if !ok { + return fmt.Errorf("that is not of type *Groups2_G") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Groups2_G but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Groups2_Gbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Groups2_G) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Groups2_G) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Groups1) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&group.Groups1{") + if this.G != nil { + s = append(s, "G: "+fmt.Sprintf("%#v", this.G)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Groups1_G) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&group.Groups1_G{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringGroup(this.Field1, "int64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringGroup(this.Field2, "float64")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Groups2) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&group.Groups2{") + if this.G != nil { + s = append(s, "G: "+fmt.Sprintf("%#v", this.G)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Groups2_G) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&group.Groups2_G{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringGroup(this.Field1, "int64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringGroup(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringGroup(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedGroups1(r randyGroup, easy bool) *Groups1 { + this := &Groups1{} + if r.Intn(10) != 0 { + v1 := r.Intn(10) + this.G = make([]*Groups1_G, v1) + for i := 0; i < v1; i++ { + this.G[i] = NewPopulatedGroups1_G(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedGroup(r, 2) + } + return this +} + +func NewPopulatedGroups1_G(r randyGroup, easy bool) *Groups1_G { + this := &Groups1_G{} + if r.Intn(10) != 0 { + v2 := int64(r.Int63()) + if r.Intn(2) == 0 { + v2 *= -1 + } + this.Field1 = &v2 + } + if r.Intn(10) != 0 { + v3 := float64(r.Float64()) + if r.Intn(2) == 0 { + v3 *= -1 + } + this.Field2 = &v3 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedGroup(r, 3) + } + return this +} + +func NewPopulatedGroups2(r randyGroup, easy bool) *Groups2 { + this := &Groups2{} + if r.Intn(10) != 0 { + this.G = NewPopulatedGroups2_G(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedGroup(r, 2) + } + return this +} + +func NewPopulatedGroups2_G(r randyGroup, easy bool) *Groups2_G { + this := &Groups2_G{} + if r.Intn(10) != 0 { + v4 := int64(r.Int63()) + if r.Intn(2) == 0 { + v4 *= -1 + } + this.Field1 = &v4 + } + if r.Intn(10) != 0 { + v5 := r.Intn(100) + this.Field2 = make([]float64, v5) + for i := 0; i < v5; i++ { + this.Field2[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedGroup(r, 3) + } + return this +} + +type randyGroup interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneGroup(r randyGroup) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringGroup(r randyGroup) string { + v6 := r.Intn(100) + tmps := make([]rune, v6) + for i := 0; i < v6; i++ { + tmps[i] = randUTF8RuneGroup(r) + } + return string(tmps) +} +func randUnrecognizedGroup(r randyGroup, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldGroup(data, r, fieldNumber, wire) + } + return data +} +func randFieldGroup(data []byte, r randyGroup, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateGroup(data, uint64(key)) + v7 := r.Int63() + if r.Intn(2) == 0 { + v7 *= -1 + } + data = encodeVarintPopulateGroup(data, uint64(v7)) + case 1: + data = encodeVarintPopulateGroup(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateGroup(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateGroup(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateGroup(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateGroup(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (this *Groups1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Groups1{`, + `G:` + strings.Replace(fmt.Sprintf("%v", this.G), "Groups1_G", "Groups1_G", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Groups1_G) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Groups1_G{`, + `Field1:` + valueToStringGroup(this.Field1) + `,`, + `Field2:` + valueToStringGroup(this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Groups2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Groups2{`, + `G:` + strings.Replace(fmt.Sprintf("%v", this.G), "Groups2_G", "Groups2_G", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Groups2_G) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Groups2_G{`, + `Field1:` + valueToStringGroup(this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringGroup(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/group/group.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/group/group.proto new file mode 100644 index 0000000000000000000000000000000000000000..c97e2611df4503c619f7d2e55336757e24adddd0 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/group/group.proto @@ -0,0 +1,63 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package group; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; + +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = false; + +message Groups1 { + repeated group G = 1 { + optional int64 Field1 = 1; + optional double Field2 = 2; + } +} + +message Groups2 { + optional group G = 1 { + optional int64 Field1 = 1; + repeated double Field2 = 2; + } +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/group/grouppb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/group/grouppb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..663510eea21f563e1daf7add34b9753e4518b207 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/group/grouppb_test.go @@ -0,0 +1,542 @@ +// Code generated by protoc-gen-gogo. +// source: group.proto +// DO NOT EDIT! + +/* +Package group is a generated protocol buffer package. + +It is generated from these files: + group.proto + +It has these top-level messages: + Groups1 + Groups2 +*/ +package group + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestGroups1Proto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedGroups1(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Groups1{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestGroups1_GProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedGroups1_G(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Groups1_G{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestGroups2Proto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedGroups2(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Groups2{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestGroups2_GProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedGroups2_G(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Groups2_G{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestGroups1JSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedGroups1(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Groups1{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestGroups1_GJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedGroups1_G(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Groups1_G{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestGroups2JSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedGroups2(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Groups2{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestGroups2_GJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedGroups2_G(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Groups2_G{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestGroups1ProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedGroups1(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Groups1{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestGroups1ProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedGroups1(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Groups1{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestGroups1_GProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedGroups1_G(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Groups1_G{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestGroups1_GProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedGroups1_G(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Groups1_G{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestGroups2ProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedGroups2(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Groups2{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestGroups2ProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedGroups2(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Groups2{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestGroups2_GProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedGroups2_G(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Groups2_G{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestGroups2_GProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedGroups2_G(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Groups2_G{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestGroupDescription(t *testing.T) { + GroupDescription() +} +func TestGroups1VerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedGroups1(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Groups1{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestGroups1_GVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedGroups1_G(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Groups1_G{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestGroups2VerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedGroups2(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Groups2{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestGroups2_GVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedGroups2_G(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Groups2_G{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestGroups1GoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedGroups1(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestGroups1_GGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedGroups1_G(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestGroups2GoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedGroups2(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestGroups2_GGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedGroups2_G(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestGroups1Stringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedGroups1(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestGroups1_GStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedGroups1_G(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestGroups2Stringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedGroups2(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestGroups2_GStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedGroups2_G(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..cf46ccc1df36a865f972917d9e97140a391c4b86 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/Makefile @@ -0,0 +1,31 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. proto.proto) + (protoc --proto_path=../../../../../:../../protobuf/:. --gogo_out=. subpkg/subproto.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/importdedup_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/importdedup_test.go new file mode 100644 index 0000000000000000000000000000000000000000..9c5e67fdd00be719ba330d791b344057594be1cd --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/importdedup_test.go @@ -0,0 +1,32 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 importdedup + +import testing "testing" + +func TestImportDedup(t *testing.T) { +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/proto.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/proto.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..23d447ba7b52d629417bcb47a8f6d1de15dd9bee --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/proto.pb.go @@ -0,0 +1,45 @@ +// Code generated by protoc-gen-gogo. +// source: proto.proto +// DO NOT EDIT! + +/* +Package importdedup is a generated protocol buffer package. + +It is generated from these files: + proto.proto + +It has these top-level messages: + Object +*/ +package importdedup + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" +import subpkg "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/subpkg" + +import github_com_gogo_protobuf_test_importdedup_subpkg "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/subpkg" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Object struct { + CustomField *github_com_gogo_protobuf_test_importdedup_subpkg.CustomType `protobuf:"bytes,1,opt,name=CustomField,customtype=github.com/gogo/protobuf/test/importdedup/subpkg.CustomType" json:"CustomField,omitempty"` + SubObject *subpkg.SubObject `protobuf:"bytes,2,opt,name=SubObject" json:"SubObject,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Object) Reset() { *m = Object{} } +func (m *Object) String() string { return proto.CompactTextString(m) } +func (*Object) ProtoMessage() {} + +func (m *Object) GetSubObject() *subpkg.SubObject { + if m != nil { + return m.SubObject + } + return nil +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/proto.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/proto.proto new file mode 100644 index 0000000000000000000000000000000000000000..494accb88a758a4af94488f9deb3e0558eaf9306 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/proto.proto @@ -0,0 +1,38 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package importdedup; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +import "github.com/gogo/protobuf/test/importdedup/subpkg/subproto.proto"; + +message Object { + optional bytes CustomField = 1 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/importdedup/subpkg.CustomType"]; + optional subpkg.SubObject SubObject = 2; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/subpkg/customtype.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/subpkg/customtype.go new file mode 100644 index 0000000000000000000000000000000000000000..9a7965769d75cd13cb5d292a9d0ca30605b9f68f --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/subpkg/customtype.go @@ -0,0 +1,29 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 subpkg + +type CustomType struct{} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/subpkg/subproto.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/subpkg/subproto.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..b2149a4a84728724ae8db902082740ae7de2e933 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/subpkg/subproto.pb.go @@ -0,0 +1,33 @@ +// Code generated by protoc-gen-gogo. +// source: subpkg/subproto.proto +// DO NOT EDIT! + +/* +Package subpkg is a generated protocol buffer package. + +It is generated from these files: + subpkg/subproto.proto + +It has these top-level messages: + SubObject +*/ +package subpkg + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type SubObject struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *SubObject) Reset() { *m = SubObject{} } +func (m *SubObject) String() string { return proto.CompactTextString(m) } +func (*SubObject) ProtoMessage() {} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/subpkg/subproto.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/subpkg/subproto.proto new file mode 100644 index 0000000000000000000000000000000000000000..6ff53e9eb4217cda59dbef86768d7668f981bb96 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/importdedup/subpkg/subproto.proto @@ -0,0 +1,34 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package subpkg; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +message SubObject { + +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..e83a2f2141077705cce00e25568b6fb9da7d7ce2 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/Makefile @@ -0,0 +1,31 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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: + (cd index && protoc --proto_path=../../../../../../:../../../protobuf/:. --gogo_out=. index.proto) + (protoc --proto_path=../../../../../:../../protobuf/:. --gogo_out=. indeximport.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/index/index.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/index/index.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..55d5a618e6999520f77d1d1179cd513a295c66d3 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/index/index.pb.go @@ -0,0 +1,490 @@ +// Code generated by protoc-gen-gogo. +// source: index.proto +// DO NOT EDIT! + +/* + Package index is a generated protocol buffer package. + + It is generated from these files: + index.proto + + It has these top-level messages: + IndexQuery +*/ +package index + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import bytes "bytes" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type IndexQuery struct { + Key *string `protobuf:"bytes,1,opt,name=Key" json:"Key,omitempty"` + Value *string `protobuf:"bytes,2,opt,name=Value" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *IndexQuery) Reset() { *m = IndexQuery{} } +func (m *IndexQuery) String() string { return proto.CompactTextString(m) } +func (*IndexQuery) ProtoMessage() {} + +func (m *IndexQuery) GetKey() string { + if m != nil && m.Key != nil { + return *m.Key + } + return "" +} + +func (m *IndexQuery) GetValue() string { + if m != nil && m.Value != nil { + return *m.Value + } + return "" +} + +func (this *IndexQuery) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*IndexQuery) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Key != nil && that1.Key != nil { + if *this.Key != *that1.Key { + return false + } + } else if this.Key != nil { + return false + } else if that1.Key != nil { + return false + } + if this.Value != nil && that1.Value != nil { + if *this.Value != *that1.Value { + return false + } + } else if this.Value != nil { + return false + } else if that1.Value != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (m *IndexQuery) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *IndexQuery) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Key != nil { + data[i] = 0xa + i++ + i = encodeVarintIndex(data, i, uint64(len(*m.Key))) + i += copy(data[i:], *m.Key) + } + if m.Value != nil { + data[i] = 0x12 + i++ + i = encodeVarintIndex(data, i, uint64(len(*m.Value))) + i += copy(data[i:], *m.Value) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Index(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Index(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintIndex(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedIndexQuery(r randyIndex, easy bool) *IndexQuery { + this := &IndexQuery{} + if r.Intn(10) != 0 { + v1 := randStringIndex(r) + this.Key = &v1 + } + if r.Intn(10) != 0 { + v2 := randStringIndex(r) + this.Value = &v2 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedIndex(r, 3) + } + return this +} + +type randyIndex interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneIndex(r randyIndex) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringIndex(r randyIndex) string { + v3 := r.Intn(100) + tmps := make([]rune, v3) + for i := 0; i < v3; i++ { + tmps[i] = randUTF8RuneIndex(r) + } + return string(tmps) +} +func randUnrecognizedIndex(r randyIndex, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldIndex(data, r, fieldNumber, wire) + } + return data +} +func randFieldIndex(data []byte, r randyIndex, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateIndex(data, uint64(key)) + v4 := r.Int63() + if r.Intn(2) == 0 { + v4 *= -1 + } + data = encodeVarintPopulateIndex(data, uint64(v4)) + case 1: + data = encodeVarintPopulateIndex(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateIndex(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateIndex(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateIndex(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateIndex(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *IndexQuery) Size() (n int) { + var l int + _ = l + if m.Key != nil { + l = len(*m.Key) + n += 1 + l + sovIndex(uint64(l)) + } + if m.Value != nil { + l = len(*m.Value) + n += 1 + l + sovIndex(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovIndex(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozIndex(x uint64) (n int) { + return sovIndex(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *IndexQuery) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowIndex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: IndexQuery: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IndexQuery: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowIndex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthIndex + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Key = &s + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowIndex + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthIndex + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Value = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipIndex(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthIndex + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipIndex(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowIndex + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowIndex + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowIndex + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthIndex + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowIndex + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipIndex(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthIndex = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowIndex = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/index/index.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/index/index.proto new file mode 100644 index 0000000000000000000000000000000000000000..4d8811bc4e99b0e5d3301ef8174768008530604e --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/index/index.proto @@ -0,0 +1,43 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package index; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.equal_all) = true; +option (gogoproto.testgen_all) = true; + +message IndexQuery { + optional string Key = 1; + optional string Value = 2; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/index/indexpb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/index/indexpb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..a3b97934a6a89c05baa821612821b4827f7cd3e0 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/index/indexpb_test.go @@ -0,0 +1,156 @@ +// Code generated by protoc-gen-gogo. +// source: index.proto +// DO NOT EDIT! + +/* +Package index is a generated protocol buffer package. + +It is generated from these files: + index.proto + +It has these top-level messages: + IndexQuery +*/ +package index + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestIndexQueryProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedIndexQuery(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &IndexQuery{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestIndexQueryMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedIndexQuery(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &IndexQuery{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestIndexQueryJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedIndexQuery(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &IndexQuery{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestIndexQueryProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedIndexQuery(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &IndexQuery{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestIndexQueryProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedIndexQuery(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &IndexQuery{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestIndexQuerySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedIndexQuery(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/indeximport.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/indeximport.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..0eec8ba638e8dfae981b514777fa28d2692e4a06 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/indeximport.pb.go @@ -0,0 +1,441 @@ +// Code generated by protoc-gen-gogo. +// source: indeximport.proto +// DO NOT EDIT! + +/* + Package indeximport is a generated protocol buffer package. + + It is generated from these files: + indeximport.proto + + It has these top-level messages: + IndexQueries +*/ +package indeximport + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" +import index "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/index" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import bytes "bytes" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type IndexQueries struct { + Queries []*index.IndexQuery `protobuf:"bytes,1,rep,name=Queries" json:"Queries,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *IndexQueries) Reset() { *m = IndexQueries{} } +func (m *IndexQueries) String() string { return proto.CompactTextString(m) } +func (*IndexQueries) ProtoMessage() {} + +func (m *IndexQueries) GetQueries() []*index.IndexQuery { + if m != nil { + return m.Queries + } + return nil +} + +func (this *IndexQueries) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*IndexQueries) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Queries) != len(that1.Queries) { + return false + } + for i := range this.Queries { + if !this.Queries[i].Equal(that1.Queries[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (m *IndexQueries) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *IndexQueries) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Queries) > 0 { + for _, msg := range m.Queries { + data[i] = 0xa + i++ + i = encodeVarintIndeximport(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Indeximport(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Indeximport(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintIndeximport(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedIndexQueries(r randyIndeximport, easy bool) *IndexQueries { + this := &IndexQueries{} + if r.Intn(10) != 0 { + v1 := r.Intn(10) + this.Queries = make([]*index.IndexQuery, v1) + for i := 0; i < v1; i++ { + this.Queries[i] = index.NewPopulatedIndexQuery(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedIndeximport(r, 2) + } + return this +} + +type randyIndeximport interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneIndeximport(r randyIndeximport) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringIndeximport(r randyIndeximport) string { + v2 := r.Intn(100) + tmps := make([]rune, v2) + for i := 0; i < v2; i++ { + tmps[i] = randUTF8RuneIndeximport(r) + } + return string(tmps) +} +func randUnrecognizedIndeximport(r randyIndeximport, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldIndeximport(data, r, fieldNumber, wire) + } + return data +} +func randFieldIndeximport(data []byte, r randyIndeximport, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateIndeximport(data, uint64(key)) + v3 := r.Int63() + if r.Intn(2) == 0 { + v3 *= -1 + } + data = encodeVarintPopulateIndeximport(data, uint64(v3)) + case 1: + data = encodeVarintPopulateIndeximport(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateIndeximport(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateIndeximport(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateIndeximport(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateIndeximport(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *IndexQueries) Size() (n int) { + var l int + _ = l + if len(m.Queries) > 0 { + for _, e := range m.Queries { + l = e.Size() + n += 1 + l + sovIndeximport(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovIndeximport(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozIndeximport(x uint64) (n int) { + return sovIndeximport(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *IndexQueries) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowIndeximport + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: IndexQueries: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IndexQueries: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Queries", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowIndeximport + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthIndeximport + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Queries = append(m.Queries, &index.IndexQuery{}) + if err := m.Queries[len(m.Queries)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipIndeximport(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthIndeximport + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipIndeximport(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowIndeximport + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowIndeximport + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowIndeximport + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthIndeximport + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowIndeximport + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipIndeximport(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthIndeximport = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowIndeximport = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/indeximport.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/indeximport.proto new file mode 100644 index 0000000000000000000000000000000000000000..1b789cb8b3a3000b0e0084a376ab9f97794c5577 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/indeximport.proto @@ -0,0 +1,44 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package indeximport; + +import "github.com/gogo/protobuf/test/indeximport-issue72/index/index.proto"; +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.equal_all) = true; +option (gogoproto.testgen_all) = true; + +message IndexQueries { + repeated index.IndexQuery Queries = 1; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/indeximportpb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/indeximportpb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..a2e600a1bdcc93b770c6ac7085a3b574dc1d6028 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/indeximport-issue72/indeximportpb_test.go @@ -0,0 +1,157 @@ +// Code generated by protoc-gen-gogo. +// source: indeximport.proto +// DO NOT EDIT! + +/* +Package indeximport is a generated protocol buffer package. + +It is generated from these files: + indeximport.proto + +It has these top-level messages: + IndexQueries +*/ +package indeximport + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import index "github.com/gogo/protobuf/test/indeximport-issue72/index" +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestIndexQueriesProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedIndexQueries(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &IndexQueries{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestIndexQueriesMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedIndexQueries(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &IndexQueries{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestIndexQueriesJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedIndexQueries(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &IndexQueries{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestIndexQueriesProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedIndexQueries(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &IndexQueries{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestIndexQueriesProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedIndexQueries(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &IndexQueries{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestIndexQueriesSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedIndexQueries(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue34/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue34/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..e6a2cc3c9f571cc8704b5f7c8d4fdcf30c80862d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue34/Makefile @@ -0,0 +1,30 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. proto.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue34/issue34_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue34/issue34_test.go new file mode 100644 index 0000000000000000000000000000000000000000..838ee45485d98e2eb9b4e2dc3d7e6427f3641b4b --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue34/issue34_test.go @@ -0,0 +1,80 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 issue34 + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "bytes" + "testing" +) + +func TestZeroLengthOptionalBytes(t *testing.T) { + roundtrip := func(f *Foo) *Foo { + data, err := proto.Marshal(f) + if err != nil { + panic(err) + } + newF := &Foo{} + err = proto.Unmarshal(data, newF) + if err != nil { + panic(err) + } + return newF + } + + f := &Foo{} + roundtrippedF := roundtrip(f) + if roundtrippedF.Bar != nil { + t.Fatalf("should be nil") + } + + f.Bar = []byte{} + roundtrippedF = roundtrip(f) + if roundtrippedF.Bar == nil { + t.Fatalf("should not be nil") + } + if len(roundtrippedF.Bar) != 0 { + t.Fatalf("should be empty") + } +} + +func TestRepeatedOptional(t *testing.T) { + repeated := &FooWithRepeated{Bar: [][]byte{[]byte("a"), []byte("b")}} + data, err := proto.Marshal(repeated) + if err != nil { + panic(err) + } + optional := &Foo{} + err = proto.Unmarshal(data, optional) + if err != nil { + panic(err) + } + + if !bytes.Equal(optional.Bar, []byte("b")) { + t.Fatalf("should return the last entry") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue34/proto.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue34/proto.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..27899d7478af66c3c42f3f09e9a86315d1a1dcba --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue34/proto.pb.go @@ -0,0 +1,324 @@ +// Code generated by protoc-gen-gogo. +// source: proto.proto +// DO NOT EDIT! + +/* +Package issue34 is a generated protocol buffer package. + +It is generated from these files: + proto.proto + +It has these top-level messages: + Foo + FooWithRepeated +*/ +package issue34 + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Foo struct { + Bar []byte `protobuf:"bytes,1,opt,name=bar" json:"bar,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Foo) Reset() { *m = Foo{} } +func (m *Foo) String() string { return proto.CompactTextString(m) } +func (*Foo) ProtoMessage() {} + +func (m *Foo) GetBar() []byte { + if m != nil { + return m.Bar + } + return nil +} + +type FooWithRepeated struct { + Bar [][]byte `protobuf:"bytes,1,rep,name=bar" json:"bar,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FooWithRepeated) Reset() { *m = FooWithRepeated{} } +func (m *FooWithRepeated) String() string { return proto.CompactTextString(m) } +func (*FooWithRepeated) ProtoMessage() {} + +func (m *FooWithRepeated) GetBar() [][]byte { + if m != nil { + return m.Bar + } + return nil +} + +func (m *Foo) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProto + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Foo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Foo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Bar", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProto + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthProto + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Bar = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipProto(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthProto + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FooWithRepeated) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProto + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FooWithRepeated: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FooWithRepeated: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Bar", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProto + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthProto + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Bar = append(m.Bar, make([]byte, postIndex-iNdEx)) + copy(m.Bar[len(m.Bar)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipProto(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthProto + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipProto(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthProto + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipProto(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthProto = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowProto = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue34/proto.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue34/proto.proto new file mode 100644 index 0000000000000000000000000000000000000000..2a2d0b1337ea823579e24e962cda984163113bc8 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue34/proto.proto @@ -0,0 +1,15 @@ +syntax = "proto2"; + +package issue34; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.unmarshaler_all) = true; + +message Foo { + optional bytes bar = 1; +} + +message FooWithRepeated { + repeated bytes bar = 1; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue42order/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue42order/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..0f09007f7582fcd378c930a13b3da274fbabbb0d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue42order/Makefile @@ -0,0 +1,30 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. issue42.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue42order/issue42.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue42order/issue42.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..18309d6d8ce439a25904491c3f1c33006b703e41 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue42order/issue42.pb.go @@ -0,0 +1,601 @@ +// Code generated by protoc-gen-gogo. +// source: issue42.proto +// DO NOT EDIT! + +/* + Package issue42 is a generated protocol buffer package. + + It is generated from these files: + issue42.proto + + It has these top-level messages: + UnorderedFields + OrderedFields +*/ +package issue42 + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type UnorderedFields struct { + A *int64 `protobuf:"varint,10,opt,name=A" json:"A,omitempty"` + B *uint64 `protobuf:"fixed64,1,opt,name=B" json:"B,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnorderedFields) Reset() { *m = UnorderedFields{} } +func (m *UnorderedFields) String() string { return proto.CompactTextString(m) } +func (*UnorderedFields) ProtoMessage() {} + +func (m *UnorderedFields) GetA() int64 { + if m != nil && m.A != nil { + return *m.A + } + return 0 +} + +func (m *UnorderedFields) GetB() uint64 { + if m != nil && m.B != nil { + return *m.B + } + return 0 +} + +type OrderedFields struct { + B *uint64 `protobuf:"fixed64,1,opt,name=B" json:"B,omitempty"` + A *int64 `protobuf:"varint,10,opt,name=A" json:"A,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OrderedFields) Reset() { *m = OrderedFields{} } +func (m *OrderedFields) String() string { return proto.CompactTextString(m) } +func (*OrderedFields) ProtoMessage() {} + +func (m *OrderedFields) GetB() uint64 { + if m != nil && m.B != nil { + return *m.B + } + return 0 +} + +func (m *OrderedFields) GetA() int64 { + if m != nil && m.A != nil { + return *m.A + } + return 0 +} + +func (m *UnorderedFields) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *UnorderedFields) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.B != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Issue42(data, i, uint64(*m.B)) + } + if m.A != nil { + data[i] = 0x50 + i++ + i = encodeVarintIssue42(data, i, uint64(*m.A)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *OrderedFields) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *OrderedFields) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.B != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Issue42(data, i, uint64(*m.B)) + } + if m.A != nil { + data[i] = 0x50 + i++ + i = encodeVarintIssue42(data, i, uint64(*m.A)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Issue42(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Issue42(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintIssue42(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedUnorderedFields(r randyIssue42, easy bool) *UnorderedFields { + this := &UnorderedFields{} + if r.Intn(10) != 0 { + v1 := uint64(uint64(r.Uint32())) + this.B = &v1 + } + if r.Intn(10) != 0 { + v2 := int64(r.Int63()) + if r.Intn(2) == 0 { + v2 *= -1 + } + this.A = &v2 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedIssue42(r, 11) + } + return this +} + +func NewPopulatedOrderedFields(r randyIssue42, easy bool) *OrderedFields { + this := &OrderedFields{} + if r.Intn(10) != 0 { + v3 := uint64(uint64(r.Uint32())) + this.B = &v3 + } + if r.Intn(10) != 0 { + v4 := int64(r.Int63()) + if r.Intn(2) == 0 { + v4 *= -1 + } + this.A = &v4 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedIssue42(r, 11) + } + return this +} + +type randyIssue42 interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneIssue42(r randyIssue42) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringIssue42(r randyIssue42) string { + v5 := r.Intn(100) + tmps := make([]rune, v5) + for i := 0; i < v5; i++ { + tmps[i] = randUTF8RuneIssue42(r) + } + return string(tmps) +} +func randUnrecognizedIssue42(r randyIssue42, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldIssue42(data, r, fieldNumber, wire) + } + return data +} +func randFieldIssue42(data []byte, r randyIssue42, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateIssue42(data, uint64(key)) + v6 := r.Int63() + if r.Intn(2) == 0 { + v6 *= -1 + } + data = encodeVarintPopulateIssue42(data, uint64(v6)) + case 1: + data = encodeVarintPopulateIssue42(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateIssue42(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateIssue42(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateIssue42(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateIssue42(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *UnorderedFields) Size() (n int) { + var l int + _ = l + if m.B != nil { + n += 9 + } + if m.A != nil { + n += 1 + sovIssue42(uint64(*m.A)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *OrderedFields) Size() (n int) { + var l int + _ = l + if m.B != nil { + n += 9 + } + if m.A != nil { + n += 1 + sovIssue42(uint64(*m.A)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovIssue42(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozIssue42(x uint64) (n int) { + return sovIssue42(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *UnorderedFields) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowIssue42 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UnorderedFields: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UnorderedFields: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.B = &v + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowIssue42 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.A = &v + default: + iNdEx = preIndex + skippy, err := skipIssue42(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthIssue42 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OrderedFields) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowIssue42 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OrderedFields: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OrderedFields: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.B = &v + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowIssue42 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.A = &v + default: + iNdEx = preIndex + skippy, err := skipIssue42(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthIssue42 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipIssue42(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowIssue42 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowIssue42 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowIssue42 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthIssue42 + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowIssue42 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipIssue42(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthIssue42 = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowIssue42 = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue42order/issue42.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue42order/issue42.proto new file mode 100644 index 0000000000000000000000000000000000000000..abaf4a63a2a28e1ced7a82ed938606d33b13b7fd --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue42order/issue42.proto @@ -0,0 +1,46 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/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. +// +// 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"; + +package issue42; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.sizer_all) = true; +option (gogoproto.marshaler_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.populate_all) = true; + +message UnorderedFields { + optional int64 A = 10; + optional fixed64 B = 1; +} + +message OrderedFields { + optional fixed64 B = 1; + optional int64 A = 10; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue42order/order_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue42order/order_test.go new file mode 100644 index 0000000000000000000000000000000000000000..7f16c8f6c04e1569dcd54fc263e289d03d5b224c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue42order/order_test.go @@ -0,0 +1,54 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 issue42 + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "bytes" + math_rand "math/rand" + "testing" + time "time" +) + +func TestIssue42Order(t *testing.T) { + unordered := NewPopulatedUnorderedFields(math_rand.New(math_rand.NewSource(time.Now().UnixNano())), false) + udata, err := proto.Marshal(unordered) + if err != nil { + t.Fatal(err) + } + ordered := &OrderedFields{} + if err := proto.Unmarshal(udata, ordered); err != nil { + t.Fatal(err) + } + data, err := proto.Marshal(ordered) + if err != nil { + t.Fatal(err) + } + if !bytes.Equal(udata, data) { + t.Fatalf("expected data to be marshaled in the same order, please sort fields before marshaling") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue8/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue8/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..e6a2cc3c9f571cc8704b5f7c8d4fdcf30c80862d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue8/Makefile @@ -0,0 +1,30 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. proto.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue8/proto.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue8/proto.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..e35947bdd8e637fccae625d6bf708f95298ace8d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue8/proto.pb.go @@ -0,0 +1,343 @@ +// Code generated by protoc-gen-gogo. +// source: proto.proto +// DO NOT EDIT! + +/* +Package proto is a generated protocol buffer package. + +It is generated from these files: + proto.proto + +It has these top-level messages: + Foo +*/ +package proto + +import proto1 "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import bytes "bytes" + +import io "io" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto1.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Foo struct { + Bar *uint64 `protobuf:"varint,1,req,name=bar" json:"bar,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Foo) Reset() { *m = Foo{} } +func (m *Foo) String() string { return proto1.CompactTextString(m) } +func (*Foo) ProtoMessage() {} + +func (m *Foo) GetBar() uint64 { + if m != nil && m.Bar != nil { + return *m.Bar + } + return 0 +} + +func (this *Foo) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Foo) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Bar != nil && that1.Bar != nil { + if *this.Bar != *that1.Bar { + return false + } + } else if this.Bar != nil { + return false + } else if that1.Bar != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func NewPopulatedFoo(r randyProto, easy bool) *Foo { + this := &Foo{} + v1 := uint64(uint64(r.Uint32())) + this.Bar = &v1 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedProto(r, 2) + } + return this +} + +type randyProto interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneProto(r randyProto) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringProto(r randyProto) string { + v2 := r.Intn(100) + tmps := make([]rune, v2) + for i := 0; i < v2; i++ { + tmps[i] = randUTF8RuneProto(r) + } + return string(tmps) +} +func randUnrecognizedProto(r randyProto, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldProto(data, r, fieldNumber, wire) + } + return data +} +func randFieldProto(data []byte, r randyProto, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateProto(data, uint64(key)) + v3 := r.Int63() + if r.Intn(2) == 0 { + v3 *= -1 + } + data = encodeVarintPopulateProto(data, uint64(v3)) + case 1: + data = encodeVarintPopulateProto(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateProto(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateProto(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateProto(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateProto(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Foo) Unmarshal(data []byte) error { + var hasFields [1]uint64 + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProto + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Foo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Foo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Bar", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProto + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Bar = &v + hasFields[0] |= uint64(0x00000001) + default: + iNdEx = preIndex + skippy, err := skipProto(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthProto + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + if hasFields[0]&uint64(0x00000001) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("bar") + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipProto(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthProto + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipProto(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthProto = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowProto = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue8/proto.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue8/proto.proto new file mode 100644 index 0000000000000000000000000000000000000000..61d23946baf94255fa1b0ca734ca957c77bda9dd --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue8/proto.proto @@ -0,0 +1,14 @@ +syntax = "proto2"; + +package proto; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.equal_all) = true; + +message Foo { + required uint64 bar = 1; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue8/protopb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue8/protopb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..12ed5cf43f6371463706195c2dab035b19606400 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/issue8/protopb_test.go @@ -0,0 +1,109 @@ +// Code generated by protoc-gen-gogo. +// source: proto.proto +// DO NOT EDIT! + +/* +Package proto is a generated protocol buffer package. + +It is generated from these files: + proto.proto + +It has these top-level messages: + Foo +*/ +package proto + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import proto1 "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto1.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestFooProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFoo(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Foo{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestFooJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFoo(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Foo{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestFooProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFoo(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Foo{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFooProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFoo(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Foo{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..96f71ef1897c689c4333ee491653552a99a34111 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/Makefile @@ -0,0 +1,33 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/protobuf/gogoproto +# +# 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. +# +# 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: + cp header.proto mapsproto2.proto + cat ../theproto3/maps.proto >> mapsproto2.proto + go install github.com/gogo/protobuf/protoc-gen-combo + protoc-gen-combo --version="3.0.0" --proto_path=../../../../../:../../protobuf/:. mapsproto2.proto \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/both/mapsproto2.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/both/mapsproto2.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..a3269b7fe89bbf51760521dd841808461757c58c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/both/mapsproto2.pb.go @@ -0,0 +1,5845 @@ +// Code generated by protoc-gen-gogo. +// source: combos/both/mapsproto2.proto +// DO NOT EDIT! + +/* + Package proto2_maps is a generated protocol buffer package. + + It is generated from these files: + combos/both/mapsproto2.proto + + It has these top-level messages: + FloatingPoint + AllMaps +*/ +package proto2_maps + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" +import github_com_gogo_protobuf_sortkeys "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/sortkeys" + +import errors "errors" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type MapEnum int32 + +const ( + MA MapEnum = 0 + MB MapEnum = 1 + MC MapEnum = 2 +) + +var MapEnum_name = map[int32]string{ + 0: "MA", + 1: "MB", + 2: "MC", +} +var MapEnum_value = map[string]int32{ + "MA": 0, + "MB": 1, + "MC": 2, +} + +func (x MapEnum) Enum() *MapEnum { + p := new(MapEnum) + *p = x + return p +} +func (x MapEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(MapEnum_name, int32(x)) +} +func (x *MapEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(MapEnum_value, data, "MapEnum") + if err != nil { + return err + } + *x = MapEnum(value) + return nil +} + +type FloatingPoint struct { + F *float64 `protobuf:"fixed64,1,opt,name=f" json:"f,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FloatingPoint) Reset() { *m = FloatingPoint{} } +func (*FloatingPoint) ProtoMessage() {} + +type AllMaps struct { + StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"` + Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"` + Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=proto2.maps.MapEnum"` + StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllMaps) Reset() { *m = AllMaps{} } +func (*AllMaps) ProtoMessage() {} + +func init() { + proto.RegisterEnum("proto2.maps.MapEnum", MapEnum_name, MapEnum_value) +} +func (this *FloatingPoint) Description() (desc *google_protobuf.FileDescriptorSet) { + return Mapsproto2Description() +} +func (this *AllMaps) Description() (desc *google_protobuf.FileDescriptorSet) { + return Mapsproto2Description() +} +func Mapsproto2Description() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/both/mapsproto2.proto"), + Package: func(v string) *string { return &v }("proto2.maps"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FloatingPoint"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("f"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }, {Name: func(v string) *string { return &v }("AllMaps"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMap"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToDoubleMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToFloatMap"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToFloatMapEntry"), + }, {Name: func(v string) *string { return &v }("Int32Map"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Int32MapEntry"), + }, {Name: func(v string) *string { return &v }("Int64Map"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Int64MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint32Map"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Uint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint64Map"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Uint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint32Map"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint64Map"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed32Map"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Fixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed32Map"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sfixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed64Map"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Fixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed64Map"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sfixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("BoolMap"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.BoolMapEntry"), + }, {Name: func(v string) *string { return &v }("StringMap"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToBytesMap"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToBytesMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToEnumMap"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToEnumMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToMsgMap"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToMsgMapEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToFloatMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("BoolMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToBytesMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToEnumMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".proto2.maps.MapEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToMsgMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("MapEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("MA"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("MB"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("MC"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (x MapEnum) String() string { + s, ok := MapEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *FloatingPoint) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return fmt.Errorf("that is not of type *FloatingPoint") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *FloatingPointbut is not nil && this == nil") + } + if this.F != nil && that1.F != nil { + if *this.F != *that1.F { + return fmt.Errorf("F this(%v) Not Equal that(%v)", *this.F, *that1.F) + } + } else if this.F != nil { + return fmt.Errorf("this.F == nil && that.F != nil") + } else if that1.F != nil { + return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *FloatingPoint) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.F != nil && that1.F != nil { + if *this.F != *that1.F { + return false + } + } else if this.F != nil { + return false + } else if that1.F != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllMaps) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllMaps) + if !ok { + return fmt.Errorf("that is not of type *AllMaps") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllMaps but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllMapsbut is not nil && this == nil") + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap)) + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i]) + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap)) + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i]) + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map)) + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i]) + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map)) + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i]) + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map)) + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i]) + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map)) + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i]) + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map)) + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i]) + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map)) + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i]) + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map)) + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i]) + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map)) + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i]) + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map)) + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i]) + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map)) + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i]) + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap)) + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i]) + } + } + if len(this.StringMap) != len(that1.StringMap) { + return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap)) + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i]) + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap)) + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i]) + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap)) + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i]) + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap)) + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AllMaps) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllMaps) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return false + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return false + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return false + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return false + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return false + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return false + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return false + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return false + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return false + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return false + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return false + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return false + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return false + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return false + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return false + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return false + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return false + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return false + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return false + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return false + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return false + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return false + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return false + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return false + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return false + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return false + } + } + if len(this.StringMap) != len(that1.StringMap) { + return false + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return false + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return false + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return false + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return false + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return false + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return false + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} + +type FloatingPointFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetF() *float64 +} + +func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message { + return NewFloatingPointFromFace(this) +} + +func (this *FloatingPoint) GetF() *float64 { + return this.F +} + +func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint { + this := &FloatingPoint{} + this.F = that.GetF() + return this +} + +type AllMapsFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetStringToDoubleMap() map[string]float64 + GetStringToFloatMap() map[string]float32 + GetInt32Map() map[int32]int32 + GetInt64Map() map[int64]int64 + GetUint32Map() map[uint32]uint32 + GetUint64Map() map[uint64]uint64 + GetSint32Map() map[int32]int32 + GetSint64Map() map[int64]int64 + GetFixed32Map() map[uint32]uint32 + GetSfixed32Map() map[int32]int32 + GetFixed64Map() map[uint64]uint64 + GetSfixed64Map() map[int64]int64 + GetBoolMap() map[bool]bool + GetStringMap() map[string]string + GetStringToBytesMap() map[string][]byte + GetStringToEnumMap() map[string]MapEnum + GetStringToMsgMap() map[string]*FloatingPoint +} + +func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAllMapsFromFace(this) +} + +func (this *AllMaps) GetStringToDoubleMap() map[string]float64 { + return this.StringToDoubleMap +} + +func (this *AllMaps) GetStringToFloatMap() map[string]float32 { + return this.StringToFloatMap +} + +func (this *AllMaps) GetInt32Map() map[int32]int32 { + return this.Int32Map +} + +func (this *AllMaps) GetInt64Map() map[int64]int64 { + return this.Int64Map +} + +func (this *AllMaps) GetUint32Map() map[uint32]uint32 { + return this.Uint32Map +} + +func (this *AllMaps) GetUint64Map() map[uint64]uint64 { + return this.Uint64Map +} + +func (this *AllMaps) GetSint32Map() map[int32]int32 { + return this.Sint32Map +} + +func (this *AllMaps) GetSint64Map() map[int64]int64 { + return this.Sint64Map +} + +func (this *AllMaps) GetFixed32Map() map[uint32]uint32 { + return this.Fixed32Map +} + +func (this *AllMaps) GetSfixed32Map() map[int32]int32 { + return this.Sfixed32Map +} + +func (this *AllMaps) GetFixed64Map() map[uint64]uint64 { + return this.Fixed64Map +} + +func (this *AllMaps) GetSfixed64Map() map[int64]int64 { + return this.Sfixed64Map +} + +func (this *AllMaps) GetBoolMap() map[bool]bool { + return this.BoolMap +} + +func (this *AllMaps) GetStringMap() map[string]string { + return this.StringMap +} + +func (this *AllMaps) GetStringToBytesMap() map[string][]byte { + return this.StringToBytesMap +} + +func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum { + return this.StringToEnumMap +} + +func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint { + return this.StringToMsgMap +} + +func NewAllMapsFromFace(that AllMapsFace) *AllMaps { + this := &AllMaps{} + this.StringToDoubleMap = that.GetStringToDoubleMap() + this.StringToFloatMap = that.GetStringToFloatMap() + this.Int32Map = that.GetInt32Map() + this.Int64Map = that.GetInt64Map() + this.Uint32Map = that.GetUint32Map() + this.Uint64Map = that.GetUint64Map() + this.Sint32Map = that.GetSint32Map() + this.Sint64Map = that.GetSint64Map() + this.Fixed32Map = that.GetFixed32Map() + this.Sfixed32Map = that.GetSfixed32Map() + this.Fixed64Map = that.GetFixed64Map() + this.Sfixed64Map = that.GetSfixed64Map() + this.BoolMap = that.GetBoolMap() + this.StringMap = that.GetStringMap() + this.StringToBytesMap = that.GetStringToBytesMap() + this.StringToEnumMap = that.GetStringToEnumMap() + this.StringToMsgMap = that.GetStringToMsgMap() + return this +} + +func (this *FloatingPoint) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&proto2_maps.FloatingPoint{") + if this.F != nil { + s = append(s, "F: "+valueToGoStringMapsproto2(this.F, "float64")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllMaps) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 21) + s = append(s, "&proto2_maps.AllMaps{") + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + if this.StringToDoubleMap != nil { + s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n") + } + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + if this.StringToFloatMap != nil { + s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n") + } + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + if this.Int32Map != nil { + s = append(s, "Int32Map: "+mapStringForInt32Map+",\n") + } + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + if this.Int64Map != nil { + s = append(s, "Int64Map: "+mapStringForInt64Map+",\n") + } + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + if this.Uint32Map != nil { + s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n") + } + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + if this.Uint64Map != nil { + s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n") + } + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + if this.Sint32Map != nil { + s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n") + } + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + if this.Sint64Map != nil { + s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n") + } + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + if this.Fixed32Map != nil { + s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n") + } + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + if this.Sfixed32Map != nil { + s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n") + } + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + if this.Fixed64Map != nil { + s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n") + } + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + if this.Sfixed64Map != nil { + s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n") + } + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + if this.BoolMap != nil { + s = append(s, "BoolMap: "+mapStringForBoolMap+",\n") + } + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + if this.StringMap != nil { + s = append(s, "StringMap: "+mapStringForStringMap+",\n") + } + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + if this.StringToBytesMap != nil { + s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n") + } + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + if this.StringToEnumMap != nil { + s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n") + } + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + if this.StringToMsgMap != nil { + s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringMapsproto2(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringMapsproto2(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *FloatingPoint) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *FloatingPoint) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.F != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(math.Float64bits(*m.F))) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AllMaps) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AllMaps) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + keysForStringToDoubleMap := make([]string, 0, len(m.StringToDoubleMap)) + for k := range m.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + for _, k := range keysForStringToDoubleMap { + data[i] = 0xa + i++ + v := m.StringToDoubleMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 8 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x11 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(math.Float64bits(v))) + } + } + if len(m.StringToFloatMap) > 0 { + keysForStringToFloatMap := make([]string, 0, len(m.StringToFloatMap)) + for k := range m.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + for _, k := range keysForStringToFloatMap { + data[i] = 0x12 + i++ + v := m.StringToFloatMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 4 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x15 + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(math.Float32bits(v))) + } + } + if len(m.Int32Map) > 0 { + keysForInt32Map := make([]int32, 0, len(m.Int32Map)) + for k := range m.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + for _, k := range keysForInt32Map { + data[i] = 0x1a + i++ + v := m.Int32Map[k] + mapSize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.Int64Map) > 0 { + keysForInt64Map := make([]int64, 0, len(m.Int64Map)) + for k := range m.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + for _, k := range keysForInt64Map { + data[i] = 0x22 + i++ + v := m.Int64Map[k] + mapSize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.Uint32Map) > 0 { + keysForUint32Map := make([]uint32, 0, len(m.Uint32Map)) + for k := range m.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + for _, k := range keysForUint32Map { + data[i] = 0x2a + i++ + v := m.Uint32Map[k] + mapSize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.Uint64Map) > 0 { + keysForUint64Map := make([]uint64, 0, len(m.Uint64Map)) + for k := range m.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + for _, k := range keysForUint64Map { + data[i] = 0x32 + i++ + v := m.Uint64Map[k] + mapSize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.Sint32Map) > 0 { + keysForSint32Map := make([]int32, 0, len(m.Sint32Map)) + for k := range m.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + for _, k := range keysForSint32Map { + data[i] = 0x3a + i++ + v := m.Sint32Map[k] + mapSize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64((uint32(k)<<1)^uint32((k>>31)))) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64((uint32(v)<<1)^uint32((v>>31)))) + } + } + if len(m.Sint64Map) > 0 { + keysForSint64Map := make([]int64, 0, len(m.Sint64Map)) + for k := range m.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + for _, k := range keysForSint64Map { + data[i] = 0x42 + i++ + v := m.Sint64Map[k] + mapSize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64((uint64(k)<<1)^uint64((k>>63)))) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64((uint64(v)<<1)^uint64((v>>63)))) + } + } + if len(m.Fixed32Map) > 0 { + keysForFixed32Map := make([]uint32, 0, len(m.Fixed32Map)) + for k := range m.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + for _, k := range keysForFixed32Map { + data[i] = 0x4a + i++ + v := m.Fixed32Map[k] + mapSize := 1 + 4 + 1 + 4 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xd + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(k)) + data[i] = 0x15 + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(v)) + } + } + if len(m.Sfixed32Map) > 0 { + keysForSfixed32Map := make([]int32, 0, len(m.Sfixed32Map)) + for k := range m.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + for _, k := range keysForSfixed32Map { + data[i] = 0x52 + i++ + v := m.Sfixed32Map[k] + mapSize := 1 + 4 + 1 + 4 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xd + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(k)) + data[i] = 0x15 + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(v)) + } + } + if len(m.Fixed64Map) > 0 { + keysForFixed64Map := make([]uint64, 0, len(m.Fixed64Map)) + for k := range m.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + for _, k := range keysForFixed64Map { + data[i] = 0x5a + i++ + v := m.Fixed64Map[k] + mapSize := 1 + 8 + 1 + 8 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x9 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(k)) + data[i] = 0x11 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(v)) + } + } + if len(m.Sfixed64Map) > 0 { + keysForSfixed64Map := make([]int64, 0, len(m.Sfixed64Map)) + for k := range m.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + for _, k := range keysForSfixed64Map { + data[i] = 0x62 + i++ + v := m.Sfixed64Map[k] + mapSize := 1 + 8 + 1 + 8 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x9 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(k)) + data[i] = 0x11 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(v)) + } + } + if len(m.BoolMap) > 0 { + keysForBoolMap := make([]bool, 0, len(m.BoolMap)) + for k := range m.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + for _, k := range keysForBoolMap { + data[i] = 0x6a + i++ + v := m.BoolMap[k] + mapSize := 1 + 1 + 1 + 1 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + if k { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x10 + i++ + if v { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.StringMap) > 0 { + keysForStringMap := make([]string, 0, len(m.StringMap)) + for k := range m.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + for _, k := range keysForStringMap { + data[i] = 0x72 + i++ + v := m.StringMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.StringToBytesMap) > 0 { + keysForStringToBytesMap := make([]string, 0, len(m.StringToBytesMap)) + for k := range m.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + for _, k := range keysForStringToBytesMap { + data[i] = 0x7a + i++ + v := m.StringToBytesMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.StringToEnumMap) > 0 { + keysForStringToEnumMap := make([]string, 0, len(m.StringToEnumMap)) + for k := range m.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + for _, k := range keysForStringToEnumMap { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + v := m.StringToEnumMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.StringToMsgMap) > 0 { + keysForStringToMsgMap := make([]string, 0, len(m.StringToMsgMap)) + for k := range m.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + for _, k := range keysForStringToMsgMap { + data[i] = 0x8a + i++ + data[i] = 0x1 + i++ + v := m.StringToMsgMap[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + msgSize + sovMapsproto2(uint64(msgSize)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v.Size())) + n1, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n1 + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Mapsproto2(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Mapsproto2(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintMapsproto2(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedFloatingPoint(r randyMapsproto2, easy bool) *FloatingPoint { + this := &FloatingPoint{} + if r.Intn(10) != 0 { + v1 := float64(r.Float64()) + if r.Intn(2) == 0 { + v1 *= -1 + } + this.F = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 2) + } + return this +} + +func NewPopulatedAllMaps(r randyMapsproto2, easy bool) *AllMaps { + this := &AllMaps{} + if r.Intn(10) != 0 { + v2 := r.Intn(10) + this.StringToDoubleMap = make(map[string]float64) + for i := 0; i < v2; i++ { + v3 := randStringMapsproto2(r) + this.StringToDoubleMap[v3] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.StringToDoubleMap[v3] *= -1 + } + } + } + if r.Intn(10) != 0 { + v4 := r.Intn(10) + this.StringToFloatMap = make(map[string]float32) + for i := 0; i < v4; i++ { + v5 := randStringMapsproto2(r) + this.StringToFloatMap[v5] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.StringToFloatMap[v5] *= -1 + } + } + } + if r.Intn(10) != 0 { + v6 := r.Intn(10) + this.Int32Map = make(map[int32]int32) + for i := 0; i < v6; i++ { + v7 := int32(r.Int31()) + this.Int32Map[v7] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Int32Map[v7] *= -1 + } + } + } + if r.Intn(10) != 0 { + v8 := r.Intn(10) + this.Int64Map = make(map[int64]int64) + for i := 0; i < v8; i++ { + v9 := int64(r.Int63()) + this.Int64Map[v9] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Int64Map[v9] *= -1 + } + } + } + if r.Intn(10) != 0 { + v10 := r.Intn(10) + this.Uint32Map = make(map[uint32]uint32) + for i := 0; i < v10; i++ { + v11 := uint32(r.Uint32()) + this.Uint32Map[v11] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v12 := r.Intn(10) + this.Uint64Map = make(map[uint64]uint64) + for i := 0; i < v12; i++ { + v13 := uint64(uint64(r.Uint32())) + this.Uint64Map[v13] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v14 := r.Intn(10) + this.Sint32Map = make(map[int32]int32) + for i := 0; i < v14; i++ { + v15 := int32(r.Int31()) + this.Sint32Map[v15] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sint32Map[v15] *= -1 + } + } + } + if r.Intn(10) != 0 { + v16 := r.Intn(10) + this.Sint64Map = make(map[int64]int64) + for i := 0; i < v16; i++ { + v17 := int64(r.Int63()) + this.Sint64Map[v17] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sint64Map[v17] *= -1 + } + } + } + if r.Intn(10) != 0 { + v18 := r.Intn(10) + this.Fixed32Map = make(map[uint32]uint32) + for i := 0; i < v18; i++ { + v19 := uint32(r.Uint32()) + this.Fixed32Map[v19] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v20 := r.Intn(10) + this.Sfixed32Map = make(map[int32]int32) + for i := 0; i < v20; i++ { + v21 := int32(r.Int31()) + this.Sfixed32Map[v21] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sfixed32Map[v21] *= -1 + } + } + } + if r.Intn(10) != 0 { + v22 := r.Intn(10) + this.Fixed64Map = make(map[uint64]uint64) + for i := 0; i < v22; i++ { + v23 := uint64(uint64(r.Uint32())) + this.Fixed64Map[v23] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v24 := r.Intn(10) + this.Sfixed64Map = make(map[int64]int64) + for i := 0; i < v24; i++ { + v25 := int64(r.Int63()) + this.Sfixed64Map[v25] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sfixed64Map[v25] *= -1 + } + } + } + if r.Intn(10) != 0 { + v26 := r.Intn(10) + this.BoolMap = make(map[bool]bool) + for i := 0; i < v26; i++ { + v27 := bool(bool(r.Intn(2) == 0)) + this.BoolMap[v27] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v28 := r.Intn(10) + this.StringMap = make(map[string]string) + for i := 0; i < v28; i++ { + this.StringMap[randStringMapsproto2(r)] = randStringMapsproto2(r) + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(10) + this.StringToBytesMap = make(map[string][]byte) + for i := 0; i < v29; i++ { + v30 := r.Intn(100) + v31 := randStringMapsproto2(r) + this.StringToBytesMap[v31] = make([]byte, v30) + for i := 0; i < v30; i++ { + this.StringToBytesMap[v31][i] = byte(r.Intn(256)) + } + } + } + if r.Intn(10) != 0 { + v32 := r.Intn(10) + this.StringToEnumMap = make(map[string]MapEnum) + for i := 0; i < v32; i++ { + this.StringToEnumMap[randStringMapsproto2(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if r.Intn(10) != 0 { + v33 := r.Intn(10) + this.StringToMsgMap = make(map[string]*FloatingPoint) + for i := 0; i < v33; i++ { + this.StringToMsgMap[randStringMapsproto2(r)] = NewPopulatedFloatingPoint(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 18) + } + return this +} + +type randyMapsproto2 interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneMapsproto2(r randyMapsproto2) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringMapsproto2(r randyMapsproto2) string { + v34 := r.Intn(100) + tmps := make([]rune, v34) + for i := 0; i < v34; i++ { + tmps[i] = randUTF8RuneMapsproto2(r) + } + return string(tmps) +} +func randUnrecognizedMapsproto2(r randyMapsproto2, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldMapsproto2(data, r, fieldNumber, wire) + } + return data +} +func randFieldMapsproto2(data []byte, r randyMapsproto2, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + v35 := r.Int63() + if r.Intn(2) == 0 { + v35 *= -1 + } + data = encodeVarintPopulateMapsproto2(data, uint64(v35)) + case 1: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateMapsproto2(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateMapsproto2(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *FloatingPoint) Size() (n int) { + var l int + _ = l + if m.F != nil { + n += 9 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllMaps) Size() (n int) { + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + for k, v := range m.StringToDoubleMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToFloatMap) > 0 { + for k, v := range m.StringToFloatMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Int32Map) > 0 { + for k, v := range m.Int32Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Int64Map) > 0 { + for k, v := range m.Int64Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Uint32Map) > 0 { + for k, v := range m.Uint32Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Uint64Map) > 0 { + for k, v := range m.Uint64Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sint32Map) > 0 { + for k, v := range m.Sint32Map { + _ = k + _ = v + mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sint64Map) > 0 { + for k, v := range m.Sint64Map { + _ = k + _ = v + mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Fixed32Map) > 0 { + for k, v := range m.Fixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sfixed32Map) > 0 { + for k, v := range m.Sfixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Fixed64Map) > 0 { + for k, v := range m.Fixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sfixed64Map) > 0 { + for k, v := range m.Sfixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.BoolMap) > 0 { + for k, v := range m.BoolMap { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + 1 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringMap) > 0 { + for k, v := range m.StringMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToBytesMap) > 0 { + for k, v := range m.StringToBytesMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToEnumMap) > 0 { + for k, v := range m.StringToEnumMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToMsgMap) > 0 { + for k, v := range m.StringToMsgMap { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + l + sovMapsproto2(uint64(l)) + n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovMapsproto2(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozMapsproto2(x uint64) (n int) { + return sovMapsproto2(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *FloatingPoint) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FloatingPoint{`, + `F:` + valueToStringMapsproto2(this.F) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllMaps) String() string { + if this == nil { + return "nil" + } + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]*float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]*float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]*int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]*int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]*uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]*uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]*int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]*int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]*uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]*int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]*uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]*int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]*bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]*string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]*MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + s := strings.Join([]string{`&AllMaps{`, + `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`, + `StringToFloatMap:` + mapStringForStringToFloatMap + `,`, + `Int32Map:` + mapStringForInt32Map + `,`, + `Int64Map:` + mapStringForInt64Map + `,`, + `Uint32Map:` + mapStringForUint32Map + `,`, + `Uint64Map:` + mapStringForUint64Map + `,`, + `Sint32Map:` + mapStringForSint32Map + `,`, + `Sint64Map:` + mapStringForSint64Map + `,`, + `Fixed32Map:` + mapStringForFixed32Map + `,`, + `Sfixed32Map:` + mapStringForSfixed32Map + `,`, + `Fixed64Map:` + mapStringForFixed64Map + `,`, + `Sfixed64Map:` + mapStringForSfixed64Map + `,`, + `BoolMap:` + mapStringForBoolMap + `,`, + `StringMap:` + mapStringForStringMap + `,`, + `StringToBytesMap:` + mapStringForStringToBytesMap + `,`, + `StringToEnumMap:` + mapStringForStringToEnumMap + `,`, + `StringToMsgMap:` + mapStringForStringToMsgMap + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringMapsproto2(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *FloatingPoint) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FloatingPoint: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FloatingPoint: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field F", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.F = &v2 + default: + iNdEx = preIndex + skippy, err := skipMapsproto2(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthMapsproto2 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AllMaps) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AllMaps: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AllMaps: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvaluetemp = uint64(data[iNdEx-8]) + mapvaluetemp |= uint64(data[iNdEx-7]) << 8 + mapvaluetemp |= uint64(data[iNdEx-6]) << 16 + mapvaluetemp |= uint64(data[iNdEx-5]) << 24 + mapvaluetemp |= uint64(data[iNdEx-4]) << 32 + mapvaluetemp |= uint64(data[iNdEx-3]) << 40 + mapvaluetemp |= uint64(data[iNdEx-2]) << 48 + mapvaluetemp |= uint64(data[iNdEx-1]) << 56 + mapvalue := math.Float64frombits(mapvaluetemp) + if m.StringToDoubleMap == nil { + m.StringToDoubleMap = make(map[string]float64) + } + m.StringToDoubleMap[mapkey] = mapvalue + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvaluetemp = uint32(data[iNdEx-4]) + mapvaluetemp |= uint32(data[iNdEx-3]) << 8 + mapvaluetemp |= uint32(data[iNdEx-2]) << 16 + mapvaluetemp |= uint32(data[iNdEx-1]) << 24 + mapvalue := math.Float32frombits(mapvaluetemp) + if m.StringToFloatMap == nil { + m.StringToFloatMap = make(map[string]float32) + } + m.StringToFloatMap[mapkey] = mapvalue + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Int32Map == nil { + m.Int32Map = make(map[int32]int32) + } + m.Int32Map[mapkey] = mapvalue + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Int64Map == nil { + m.Int64Map = make(map[int64]int64) + } + m.Int64Map[mapkey] = mapvalue + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Uint32Map == nil { + m.Uint32Map = make(map[uint32]uint32) + } + m.Uint32Map[mapkey] = mapvalue + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Uint64Map == nil { + m.Uint64Map = make(map[uint64]uint64) + } + m.Uint64Map[mapkey] = mapvalue + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31)) + mapkey := int32(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31)) + mapvalue := int32(mapvaluetemp) + if m.Sint32Map == nil { + m.Sint32Map = make(map[int32]int32) + } + m.Sint32Map[mapkey] = mapvalue + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63) + mapkey := int64(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63) + mapvalue := int64(mapvaluetemp) + if m.Sint64Map == nil { + m.Sint64Map = make(map[int64]int64) + } + m.Sint64Map[mapkey] = mapvalue + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapkey = uint32(data[iNdEx-4]) + mapkey |= uint32(data[iNdEx-3]) << 8 + mapkey |= uint32(data[iNdEx-2]) << 16 + mapkey |= uint32(data[iNdEx-1]) << 24 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvalue = uint32(data[iNdEx-4]) + mapvalue |= uint32(data[iNdEx-3]) << 8 + mapvalue |= uint32(data[iNdEx-2]) << 16 + mapvalue |= uint32(data[iNdEx-1]) << 24 + if m.Fixed32Map == nil { + m.Fixed32Map = make(map[uint32]uint32) + } + m.Fixed32Map[mapkey] = mapvalue + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapkey = int32(data[iNdEx-4]) + mapkey |= int32(data[iNdEx-3]) << 8 + mapkey |= int32(data[iNdEx-2]) << 16 + mapkey |= int32(data[iNdEx-1]) << 24 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvalue = int32(data[iNdEx-4]) + mapvalue |= int32(data[iNdEx-3]) << 8 + mapvalue |= int32(data[iNdEx-2]) << 16 + mapvalue |= int32(data[iNdEx-1]) << 24 + if m.Sfixed32Map == nil { + m.Sfixed32Map = make(map[int32]int32) + } + m.Sfixed32Map[mapkey] = mapvalue + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapkey = uint64(data[iNdEx-8]) + mapkey |= uint64(data[iNdEx-7]) << 8 + mapkey |= uint64(data[iNdEx-6]) << 16 + mapkey |= uint64(data[iNdEx-5]) << 24 + mapkey |= uint64(data[iNdEx-4]) << 32 + mapkey |= uint64(data[iNdEx-3]) << 40 + mapkey |= uint64(data[iNdEx-2]) << 48 + mapkey |= uint64(data[iNdEx-1]) << 56 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvalue = uint64(data[iNdEx-8]) + mapvalue |= uint64(data[iNdEx-7]) << 8 + mapvalue |= uint64(data[iNdEx-6]) << 16 + mapvalue |= uint64(data[iNdEx-5]) << 24 + mapvalue |= uint64(data[iNdEx-4]) << 32 + mapvalue |= uint64(data[iNdEx-3]) << 40 + mapvalue |= uint64(data[iNdEx-2]) << 48 + mapvalue |= uint64(data[iNdEx-1]) << 56 + if m.Fixed64Map == nil { + m.Fixed64Map = make(map[uint64]uint64) + } + m.Fixed64Map[mapkey] = mapvalue + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapkey = int64(data[iNdEx-8]) + mapkey |= int64(data[iNdEx-7]) << 8 + mapkey |= int64(data[iNdEx-6]) << 16 + mapkey |= int64(data[iNdEx-5]) << 24 + mapkey |= int64(data[iNdEx-4]) << 32 + mapkey |= int64(data[iNdEx-3]) << 40 + mapkey |= int64(data[iNdEx-2]) << 48 + mapkey |= int64(data[iNdEx-1]) << 56 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvalue = int64(data[iNdEx-8]) + mapvalue |= int64(data[iNdEx-7]) << 8 + mapvalue |= int64(data[iNdEx-6]) << 16 + mapvalue |= int64(data[iNdEx-5]) << 24 + mapvalue |= int64(data[iNdEx-4]) << 32 + mapvalue |= int64(data[iNdEx-3]) << 40 + mapvalue |= int64(data[iNdEx-2]) << 48 + mapvalue |= int64(data[iNdEx-1]) << 56 + if m.Sfixed64Map == nil { + m.Sfixed64Map = make(map[int64]int64) + } + m.Sfixed64Map[mapkey] = mapvalue + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkey := bool(mapkeytemp != 0) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvalue := bool(mapvaluetemp != 0) + if m.BoolMap == nil { + m.BoolMap = make(map[bool]bool) + } + m.BoolMap[mapkey] = mapvalue + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthMapsproto2 + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue := string(data[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + if m.StringMap == nil { + m.StringMap = make(map[string]string) + } + m.StringMap[mapkey] = mapvalue + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapbyteLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthMapsproto2 + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := make([]byte, mapbyteLen) + copy(mapvalue, data[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + if m.StringToBytesMap == nil { + m.StringToBytesMap = make(map[string][]byte) + } + m.StringToBytesMap[mapkey] = mapvalue + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue MapEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (MapEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.StringToEnumMap == nil { + m.StringToEnumMap = make(map[string]MapEnum) + } + m.StringToEnumMap[mapkey] = mapvalue + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthMapsproto2 + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &FloatingPoint{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.StringToMsgMap == nil { + m.StringToMsgMap = make(map[string]*FloatingPoint) + } + m.StringToMsgMap[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipMapsproto2(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthMapsproto2 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipMapsproto2(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthMapsproto2 + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipMapsproto2(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthMapsproto2 = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowMapsproto2 = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/both/mapsproto2.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/both/mapsproto2.proto new file mode 100644 index 0000000000000000000000000000000000000000..d9457a061d9dc6fcc9603c8af7039ab0c3604730 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/both/mapsproto2.proto @@ -0,0 +1,93 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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"; + +package proto2.maps; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message FloatingPoint { + optional double f = 1; +} + +enum MapEnum { + MA = 0; + MB = 1; + MC = 2; +} + +message AllMaps { + map StringToDoubleMap = 1; + map StringToFloatMap = 2; + map Int32Map = 3; + map Int64Map = 4; + map Uint32Map = 5; + map Uint64Map = 6; + map Sint32Map = 7; + map Sint64Map = 8; + map Fixed32Map = 9; + map Sfixed32Map = 10; + map Fixed64Map = 11; + map Sfixed64Map = 12; + map BoolMap = 13; + map StringMap = 14; + map StringToBytesMap = 15; + map StringToEnumMap = 16; + map StringToMsgMap = 17; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/both/mapsproto2pb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/both/mapsproto2pb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..b9cd747dcb6dda0918c228adbe1adb41ed6fe9aa --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/both/mapsproto2pb_test.go @@ -0,0 +1,514 @@ +// Code generated by protoc-gen-gogo. +// source: combos/both/mapsproto2.proto +// DO NOT EDIT! + +/* +Package proto2_maps is a generated protocol buffer package. + +It is generated from these files: + combos/both/mapsproto2.proto + +It has these top-level messages: + FloatingPoint + AllMaps +*/ +package proto2_maps + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestFloatingPointProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestFloatingPointMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkFloatingPointProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedFloatingPoint(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &FloatingPoint{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAllMapsMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAllMapsProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMaps(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AllMaps{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllMapsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestFloatingPointProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMapsproto2Description(t *testing.T) { + Mapsproto2Description() +} +func TestFloatingPointVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllMapsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestFloatingPointFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAllMapsFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestFloatingPointGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllMapsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestFloatingPointSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkFloatingPointSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAllMapsSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllMapsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/marshaler/mapsproto2.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/marshaler/mapsproto2.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..3f446992e2e80ee5225aef767cf3cf72f7db4807 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/marshaler/mapsproto2.pb.go @@ -0,0 +1,4003 @@ +// Code generated by protoc-gen-gogo. +// source: combos/marshaler/mapsproto2.proto +// DO NOT EDIT! + +/* +Package proto2_maps is a generated protocol buffer package. + +It is generated from these files: + combos/marshaler/mapsproto2.proto + +It has these top-level messages: + FloatingPoint + AllMaps +*/ +package proto2_maps + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" +import github_com_gogo_protobuf_sortkeys "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/sortkeys" + +import errors "errors" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type MapEnum int32 + +const ( + MA MapEnum = 0 + MB MapEnum = 1 + MC MapEnum = 2 +) + +var MapEnum_name = map[int32]string{ + 0: "MA", + 1: "MB", + 2: "MC", +} +var MapEnum_value = map[string]int32{ + "MA": 0, + "MB": 1, + "MC": 2, +} + +func (x MapEnum) Enum() *MapEnum { + p := new(MapEnum) + *p = x + return p +} +func (x MapEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(MapEnum_name, int32(x)) +} +func (x *MapEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(MapEnum_value, data, "MapEnum") + if err != nil { + return err + } + *x = MapEnum(value) + return nil +} + +type FloatingPoint struct { + F *float64 `protobuf:"fixed64,1,opt,name=f" json:"f,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FloatingPoint) Reset() { *m = FloatingPoint{} } +func (*FloatingPoint) ProtoMessage() {} + +type AllMaps struct { + StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"` + Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"` + Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=proto2.maps.MapEnum"` + StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllMaps) Reset() { *m = AllMaps{} } +func (*AllMaps) ProtoMessage() {} + +func init() { + proto.RegisterEnum("proto2.maps.MapEnum", MapEnum_name, MapEnum_value) +} +func (this *FloatingPoint) Description() (desc *google_protobuf.FileDescriptorSet) { + return Mapsproto2Description() +} +func (this *AllMaps) Description() (desc *google_protobuf.FileDescriptorSet) { + return Mapsproto2Description() +} +func Mapsproto2Description() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/marshaler/mapsproto2.proto"), + Package: func(v string) *string { return &v }("proto2.maps"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FloatingPoint"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("f"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }, {Name: func(v string) *string { return &v }("AllMaps"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMap"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToDoubleMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToFloatMap"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToFloatMapEntry"), + }, {Name: func(v string) *string { return &v }("Int32Map"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Int32MapEntry"), + }, {Name: func(v string) *string { return &v }("Int64Map"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Int64MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint32Map"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Uint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint64Map"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Uint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint32Map"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint64Map"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed32Map"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Fixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed32Map"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sfixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed64Map"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Fixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed64Map"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sfixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("BoolMap"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.BoolMapEntry"), + }, {Name: func(v string) *string { return &v }("StringMap"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToBytesMap"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToBytesMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToEnumMap"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToEnumMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToMsgMap"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToMsgMapEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToFloatMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("BoolMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToBytesMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToEnumMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".proto2.maps.MapEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToMsgMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("MapEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("MA"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("MB"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("MC"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (x MapEnum) String() string { + s, ok := MapEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *FloatingPoint) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return fmt.Errorf("that is not of type *FloatingPoint") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *FloatingPointbut is not nil && this == nil") + } + if this.F != nil && that1.F != nil { + if *this.F != *that1.F { + return fmt.Errorf("F this(%v) Not Equal that(%v)", *this.F, *that1.F) + } + } else if this.F != nil { + return fmt.Errorf("this.F == nil && that.F != nil") + } else if that1.F != nil { + return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *FloatingPoint) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.F != nil && that1.F != nil { + if *this.F != *that1.F { + return false + } + } else if this.F != nil { + return false + } else if that1.F != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllMaps) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllMaps) + if !ok { + return fmt.Errorf("that is not of type *AllMaps") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllMaps but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllMapsbut is not nil && this == nil") + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap)) + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i]) + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap)) + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i]) + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map)) + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i]) + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map)) + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i]) + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map)) + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i]) + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map)) + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i]) + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map)) + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i]) + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map)) + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i]) + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map)) + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i]) + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map)) + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i]) + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map)) + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i]) + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map)) + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i]) + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap)) + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i]) + } + } + if len(this.StringMap) != len(that1.StringMap) { + return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap)) + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i]) + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap)) + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i]) + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap)) + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i]) + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap)) + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AllMaps) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllMaps) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return false + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return false + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return false + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return false + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return false + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return false + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return false + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return false + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return false + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return false + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return false + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return false + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return false + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return false + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return false + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return false + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return false + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return false + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return false + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return false + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return false + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return false + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return false + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return false + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return false + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return false + } + } + if len(this.StringMap) != len(that1.StringMap) { + return false + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return false + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return false + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return false + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return false + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return false + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return false + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} + +type FloatingPointFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetF() *float64 +} + +func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message { + return NewFloatingPointFromFace(this) +} + +func (this *FloatingPoint) GetF() *float64 { + return this.F +} + +func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint { + this := &FloatingPoint{} + this.F = that.GetF() + return this +} + +type AllMapsFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetStringToDoubleMap() map[string]float64 + GetStringToFloatMap() map[string]float32 + GetInt32Map() map[int32]int32 + GetInt64Map() map[int64]int64 + GetUint32Map() map[uint32]uint32 + GetUint64Map() map[uint64]uint64 + GetSint32Map() map[int32]int32 + GetSint64Map() map[int64]int64 + GetFixed32Map() map[uint32]uint32 + GetSfixed32Map() map[int32]int32 + GetFixed64Map() map[uint64]uint64 + GetSfixed64Map() map[int64]int64 + GetBoolMap() map[bool]bool + GetStringMap() map[string]string + GetStringToBytesMap() map[string][]byte + GetStringToEnumMap() map[string]MapEnum + GetStringToMsgMap() map[string]*FloatingPoint +} + +func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAllMapsFromFace(this) +} + +func (this *AllMaps) GetStringToDoubleMap() map[string]float64 { + return this.StringToDoubleMap +} + +func (this *AllMaps) GetStringToFloatMap() map[string]float32 { + return this.StringToFloatMap +} + +func (this *AllMaps) GetInt32Map() map[int32]int32 { + return this.Int32Map +} + +func (this *AllMaps) GetInt64Map() map[int64]int64 { + return this.Int64Map +} + +func (this *AllMaps) GetUint32Map() map[uint32]uint32 { + return this.Uint32Map +} + +func (this *AllMaps) GetUint64Map() map[uint64]uint64 { + return this.Uint64Map +} + +func (this *AllMaps) GetSint32Map() map[int32]int32 { + return this.Sint32Map +} + +func (this *AllMaps) GetSint64Map() map[int64]int64 { + return this.Sint64Map +} + +func (this *AllMaps) GetFixed32Map() map[uint32]uint32 { + return this.Fixed32Map +} + +func (this *AllMaps) GetSfixed32Map() map[int32]int32 { + return this.Sfixed32Map +} + +func (this *AllMaps) GetFixed64Map() map[uint64]uint64 { + return this.Fixed64Map +} + +func (this *AllMaps) GetSfixed64Map() map[int64]int64 { + return this.Sfixed64Map +} + +func (this *AllMaps) GetBoolMap() map[bool]bool { + return this.BoolMap +} + +func (this *AllMaps) GetStringMap() map[string]string { + return this.StringMap +} + +func (this *AllMaps) GetStringToBytesMap() map[string][]byte { + return this.StringToBytesMap +} + +func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum { + return this.StringToEnumMap +} + +func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint { + return this.StringToMsgMap +} + +func NewAllMapsFromFace(that AllMapsFace) *AllMaps { + this := &AllMaps{} + this.StringToDoubleMap = that.GetStringToDoubleMap() + this.StringToFloatMap = that.GetStringToFloatMap() + this.Int32Map = that.GetInt32Map() + this.Int64Map = that.GetInt64Map() + this.Uint32Map = that.GetUint32Map() + this.Uint64Map = that.GetUint64Map() + this.Sint32Map = that.GetSint32Map() + this.Sint64Map = that.GetSint64Map() + this.Fixed32Map = that.GetFixed32Map() + this.Sfixed32Map = that.GetSfixed32Map() + this.Fixed64Map = that.GetFixed64Map() + this.Sfixed64Map = that.GetSfixed64Map() + this.BoolMap = that.GetBoolMap() + this.StringMap = that.GetStringMap() + this.StringToBytesMap = that.GetStringToBytesMap() + this.StringToEnumMap = that.GetStringToEnumMap() + this.StringToMsgMap = that.GetStringToMsgMap() + return this +} + +func (this *FloatingPoint) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&proto2_maps.FloatingPoint{") + if this.F != nil { + s = append(s, "F: "+valueToGoStringMapsproto2(this.F, "float64")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllMaps) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 21) + s = append(s, "&proto2_maps.AllMaps{") + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + if this.StringToDoubleMap != nil { + s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n") + } + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + if this.StringToFloatMap != nil { + s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n") + } + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + if this.Int32Map != nil { + s = append(s, "Int32Map: "+mapStringForInt32Map+",\n") + } + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + if this.Int64Map != nil { + s = append(s, "Int64Map: "+mapStringForInt64Map+",\n") + } + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + if this.Uint32Map != nil { + s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n") + } + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + if this.Uint64Map != nil { + s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n") + } + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + if this.Sint32Map != nil { + s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n") + } + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + if this.Sint64Map != nil { + s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n") + } + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + if this.Fixed32Map != nil { + s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n") + } + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + if this.Sfixed32Map != nil { + s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n") + } + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + if this.Fixed64Map != nil { + s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n") + } + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + if this.Sfixed64Map != nil { + s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n") + } + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + if this.BoolMap != nil { + s = append(s, "BoolMap: "+mapStringForBoolMap+",\n") + } + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + if this.StringMap != nil { + s = append(s, "StringMap: "+mapStringForStringMap+",\n") + } + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + if this.StringToBytesMap != nil { + s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n") + } + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + if this.StringToEnumMap != nil { + s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n") + } + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + if this.StringToMsgMap != nil { + s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringMapsproto2(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringMapsproto2(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *FloatingPoint) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *FloatingPoint) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.F != nil { + data[i] = 0x9 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(math.Float64bits(*m.F))) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AllMaps) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AllMaps) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + keysForStringToDoubleMap := make([]string, 0, len(m.StringToDoubleMap)) + for k := range m.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + for _, k := range keysForStringToDoubleMap { + data[i] = 0xa + i++ + v := m.StringToDoubleMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 8 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x11 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(math.Float64bits(v))) + } + } + if len(m.StringToFloatMap) > 0 { + keysForStringToFloatMap := make([]string, 0, len(m.StringToFloatMap)) + for k := range m.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + for _, k := range keysForStringToFloatMap { + data[i] = 0x12 + i++ + v := m.StringToFloatMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 4 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x15 + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(math.Float32bits(v))) + } + } + if len(m.Int32Map) > 0 { + keysForInt32Map := make([]int32, 0, len(m.Int32Map)) + for k := range m.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + for _, k := range keysForInt32Map { + data[i] = 0x1a + i++ + v := m.Int32Map[k] + mapSize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.Int64Map) > 0 { + keysForInt64Map := make([]int64, 0, len(m.Int64Map)) + for k := range m.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + for _, k := range keysForInt64Map { + data[i] = 0x22 + i++ + v := m.Int64Map[k] + mapSize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.Uint32Map) > 0 { + keysForUint32Map := make([]uint32, 0, len(m.Uint32Map)) + for k := range m.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + for _, k := range keysForUint32Map { + data[i] = 0x2a + i++ + v := m.Uint32Map[k] + mapSize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.Uint64Map) > 0 { + keysForUint64Map := make([]uint64, 0, len(m.Uint64Map)) + for k := range m.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + for _, k := range keysForUint64Map { + data[i] = 0x32 + i++ + v := m.Uint64Map[k] + mapSize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.Sint32Map) > 0 { + keysForSint32Map := make([]int32, 0, len(m.Sint32Map)) + for k := range m.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + for _, k := range keysForSint32Map { + data[i] = 0x3a + i++ + v := m.Sint32Map[k] + mapSize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64((uint32(k)<<1)^uint32((k>>31)))) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64((uint32(v)<<1)^uint32((v>>31)))) + } + } + if len(m.Sint64Map) > 0 { + keysForSint64Map := make([]int64, 0, len(m.Sint64Map)) + for k := range m.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + for _, k := range keysForSint64Map { + data[i] = 0x42 + i++ + v := m.Sint64Map[k] + mapSize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64((uint64(k)<<1)^uint64((k>>63)))) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64((uint64(v)<<1)^uint64((v>>63)))) + } + } + if len(m.Fixed32Map) > 0 { + keysForFixed32Map := make([]uint32, 0, len(m.Fixed32Map)) + for k := range m.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + for _, k := range keysForFixed32Map { + data[i] = 0x4a + i++ + v := m.Fixed32Map[k] + mapSize := 1 + 4 + 1 + 4 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xd + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(k)) + data[i] = 0x15 + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(v)) + } + } + if len(m.Sfixed32Map) > 0 { + keysForSfixed32Map := make([]int32, 0, len(m.Sfixed32Map)) + for k := range m.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + for _, k := range keysForSfixed32Map { + data[i] = 0x52 + i++ + v := m.Sfixed32Map[k] + mapSize := 1 + 4 + 1 + 4 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xd + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(k)) + data[i] = 0x15 + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(v)) + } + } + if len(m.Fixed64Map) > 0 { + keysForFixed64Map := make([]uint64, 0, len(m.Fixed64Map)) + for k := range m.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + for _, k := range keysForFixed64Map { + data[i] = 0x5a + i++ + v := m.Fixed64Map[k] + mapSize := 1 + 8 + 1 + 8 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x9 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(k)) + data[i] = 0x11 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(v)) + } + } + if len(m.Sfixed64Map) > 0 { + keysForSfixed64Map := make([]int64, 0, len(m.Sfixed64Map)) + for k := range m.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + for _, k := range keysForSfixed64Map { + data[i] = 0x62 + i++ + v := m.Sfixed64Map[k] + mapSize := 1 + 8 + 1 + 8 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x9 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(k)) + data[i] = 0x11 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(v)) + } + } + if len(m.BoolMap) > 0 { + keysForBoolMap := make([]bool, 0, len(m.BoolMap)) + for k := range m.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + for _, k := range keysForBoolMap { + data[i] = 0x6a + i++ + v := m.BoolMap[k] + mapSize := 1 + 1 + 1 + 1 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + if k { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x10 + i++ + if v { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.StringMap) > 0 { + keysForStringMap := make([]string, 0, len(m.StringMap)) + for k := range m.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + for _, k := range keysForStringMap { + data[i] = 0x72 + i++ + v := m.StringMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.StringToBytesMap) > 0 { + keysForStringToBytesMap := make([]string, 0, len(m.StringToBytesMap)) + for k := range m.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + for _, k := range keysForStringToBytesMap { + data[i] = 0x7a + i++ + v := m.StringToBytesMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.StringToEnumMap) > 0 { + keysForStringToEnumMap := make([]string, 0, len(m.StringToEnumMap)) + for k := range m.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + for _, k := range keysForStringToEnumMap { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + v := m.StringToEnumMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.StringToMsgMap) > 0 { + keysForStringToMsgMap := make([]string, 0, len(m.StringToMsgMap)) + for k := range m.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + for _, k := range keysForStringToMsgMap { + data[i] = 0x8a + i++ + data[i] = 0x1 + i++ + v := m.StringToMsgMap[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + msgSize + sovMapsproto2(uint64(msgSize)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v.Size())) + n1, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n1 + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Mapsproto2(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Mapsproto2(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintMapsproto2(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedFloatingPoint(r randyMapsproto2, easy bool) *FloatingPoint { + this := &FloatingPoint{} + if r.Intn(10) != 0 { + v1 := float64(r.Float64()) + if r.Intn(2) == 0 { + v1 *= -1 + } + this.F = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 2) + } + return this +} + +func NewPopulatedAllMaps(r randyMapsproto2, easy bool) *AllMaps { + this := &AllMaps{} + if r.Intn(10) != 0 { + v2 := r.Intn(10) + this.StringToDoubleMap = make(map[string]float64) + for i := 0; i < v2; i++ { + v3 := randStringMapsproto2(r) + this.StringToDoubleMap[v3] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.StringToDoubleMap[v3] *= -1 + } + } + } + if r.Intn(10) != 0 { + v4 := r.Intn(10) + this.StringToFloatMap = make(map[string]float32) + for i := 0; i < v4; i++ { + v5 := randStringMapsproto2(r) + this.StringToFloatMap[v5] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.StringToFloatMap[v5] *= -1 + } + } + } + if r.Intn(10) != 0 { + v6 := r.Intn(10) + this.Int32Map = make(map[int32]int32) + for i := 0; i < v6; i++ { + v7 := int32(r.Int31()) + this.Int32Map[v7] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Int32Map[v7] *= -1 + } + } + } + if r.Intn(10) != 0 { + v8 := r.Intn(10) + this.Int64Map = make(map[int64]int64) + for i := 0; i < v8; i++ { + v9 := int64(r.Int63()) + this.Int64Map[v9] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Int64Map[v9] *= -1 + } + } + } + if r.Intn(10) != 0 { + v10 := r.Intn(10) + this.Uint32Map = make(map[uint32]uint32) + for i := 0; i < v10; i++ { + v11 := uint32(r.Uint32()) + this.Uint32Map[v11] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v12 := r.Intn(10) + this.Uint64Map = make(map[uint64]uint64) + for i := 0; i < v12; i++ { + v13 := uint64(uint64(r.Uint32())) + this.Uint64Map[v13] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v14 := r.Intn(10) + this.Sint32Map = make(map[int32]int32) + for i := 0; i < v14; i++ { + v15 := int32(r.Int31()) + this.Sint32Map[v15] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sint32Map[v15] *= -1 + } + } + } + if r.Intn(10) != 0 { + v16 := r.Intn(10) + this.Sint64Map = make(map[int64]int64) + for i := 0; i < v16; i++ { + v17 := int64(r.Int63()) + this.Sint64Map[v17] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sint64Map[v17] *= -1 + } + } + } + if r.Intn(10) != 0 { + v18 := r.Intn(10) + this.Fixed32Map = make(map[uint32]uint32) + for i := 0; i < v18; i++ { + v19 := uint32(r.Uint32()) + this.Fixed32Map[v19] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v20 := r.Intn(10) + this.Sfixed32Map = make(map[int32]int32) + for i := 0; i < v20; i++ { + v21 := int32(r.Int31()) + this.Sfixed32Map[v21] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sfixed32Map[v21] *= -1 + } + } + } + if r.Intn(10) != 0 { + v22 := r.Intn(10) + this.Fixed64Map = make(map[uint64]uint64) + for i := 0; i < v22; i++ { + v23 := uint64(uint64(r.Uint32())) + this.Fixed64Map[v23] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v24 := r.Intn(10) + this.Sfixed64Map = make(map[int64]int64) + for i := 0; i < v24; i++ { + v25 := int64(r.Int63()) + this.Sfixed64Map[v25] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sfixed64Map[v25] *= -1 + } + } + } + if r.Intn(10) != 0 { + v26 := r.Intn(10) + this.BoolMap = make(map[bool]bool) + for i := 0; i < v26; i++ { + v27 := bool(bool(r.Intn(2) == 0)) + this.BoolMap[v27] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v28 := r.Intn(10) + this.StringMap = make(map[string]string) + for i := 0; i < v28; i++ { + this.StringMap[randStringMapsproto2(r)] = randStringMapsproto2(r) + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(10) + this.StringToBytesMap = make(map[string][]byte) + for i := 0; i < v29; i++ { + v30 := r.Intn(100) + v31 := randStringMapsproto2(r) + this.StringToBytesMap[v31] = make([]byte, v30) + for i := 0; i < v30; i++ { + this.StringToBytesMap[v31][i] = byte(r.Intn(256)) + } + } + } + if r.Intn(10) != 0 { + v32 := r.Intn(10) + this.StringToEnumMap = make(map[string]MapEnum) + for i := 0; i < v32; i++ { + this.StringToEnumMap[randStringMapsproto2(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if r.Intn(10) != 0 { + v33 := r.Intn(10) + this.StringToMsgMap = make(map[string]*FloatingPoint) + for i := 0; i < v33; i++ { + this.StringToMsgMap[randStringMapsproto2(r)] = NewPopulatedFloatingPoint(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 18) + } + return this +} + +type randyMapsproto2 interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneMapsproto2(r randyMapsproto2) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringMapsproto2(r randyMapsproto2) string { + v34 := r.Intn(100) + tmps := make([]rune, v34) + for i := 0; i < v34; i++ { + tmps[i] = randUTF8RuneMapsproto2(r) + } + return string(tmps) +} +func randUnrecognizedMapsproto2(r randyMapsproto2, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldMapsproto2(data, r, fieldNumber, wire) + } + return data +} +func randFieldMapsproto2(data []byte, r randyMapsproto2, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + v35 := r.Int63() + if r.Intn(2) == 0 { + v35 *= -1 + } + data = encodeVarintPopulateMapsproto2(data, uint64(v35)) + case 1: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateMapsproto2(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateMapsproto2(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *FloatingPoint) Size() (n int) { + var l int + _ = l + if m.F != nil { + n += 9 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllMaps) Size() (n int) { + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + for k, v := range m.StringToDoubleMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToFloatMap) > 0 { + for k, v := range m.StringToFloatMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Int32Map) > 0 { + for k, v := range m.Int32Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Int64Map) > 0 { + for k, v := range m.Int64Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Uint32Map) > 0 { + for k, v := range m.Uint32Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Uint64Map) > 0 { + for k, v := range m.Uint64Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sint32Map) > 0 { + for k, v := range m.Sint32Map { + _ = k + _ = v + mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sint64Map) > 0 { + for k, v := range m.Sint64Map { + _ = k + _ = v + mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Fixed32Map) > 0 { + for k, v := range m.Fixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sfixed32Map) > 0 { + for k, v := range m.Sfixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Fixed64Map) > 0 { + for k, v := range m.Fixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sfixed64Map) > 0 { + for k, v := range m.Sfixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.BoolMap) > 0 { + for k, v := range m.BoolMap { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + 1 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringMap) > 0 { + for k, v := range m.StringMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToBytesMap) > 0 { + for k, v := range m.StringToBytesMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToEnumMap) > 0 { + for k, v := range m.StringToEnumMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToMsgMap) > 0 { + for k, v := range m.StringToMsgMap { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + l + sovMapsproto2(uint64(l)) + n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovMapsproto2(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozMapsproto2(x uint64) (n int) { + return sovMapsproto2(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *FloatingPoint) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FloatingPoint{`, + `F:` + valueToStringMapsproto2(this.F) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllMaps) String() string { + if this == nil { + return "nil" + } + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]*float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]*float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]*int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]*int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]*uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]*uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]*int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]*int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]*uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]*int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]*uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]*int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]*bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]*string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]*MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + s := strings.Join([]string{`&AllMaps{`, + `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`, + `StringToFloatMap:` + mapStringForStringToFloatMap + `,`, + `Int32Map:` + mapStringForInt32Map + `,`, + `Int64Map:` + mapStringForInt64Map + `,`, + `Uint32Map:` + mapStringForUint32Map + `,`, + `Uint64Map:` + mapStringForUint64Map + `,`, + `Sint32Map:` + mapStringForSint32Map + `,`, + `Sint64Map:` + mapStringForSint64Map + `,`, + `Fixed32Map:` + mapStringForFixed32Map + `,`, + `Sfixed32Map:` + mapStringForSfixed32Map + `,`, + `Fixed64Map:` + mapStringForFixed64Map + `,`, + `Sfixed64Map:` + mapStringForSfixed64Map + `,`, + `BoolMap:` + mapStringForBoolMap + `,`, + `StringMap:` + mapStringForStringMap + `,`, + `StringToBytesMap:` + mapStringForStringToBytesMap + `,`, + `StringToEnumMap:` + mapStringForStringToEnumMap + `,`, + `StringToMsgMap:` + mapStringForStringToMsgMap + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringMapsproto2(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/marshaler/mapsproto2.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/marshaler/mapsproto2.proto new file mode 100644 index 0000000000000000000000000000000000000000..ef160d90b76aec6f0eea529888ba56d7863f7db5 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/marshaler/mapsproto2.proto @@ -0,0 +1,93 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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"; + +package proto2.maps; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message FloatingPoint { + optional double f = 1; +} + +enum MapEnum { + MA = 0; + MB = 1; + MC = 2; +} + +message AllMaps { + map StringToDoubleMap = 1; + map StringToFloatMap = 2; + map Int32Map = 3; + map Int64Map = 4; + map Uint32Map = 5; + map Uint64Map = 6; + map Sint32Map = 7; + map Sint64Map = 8; + map Fixed32Map = 9; + map Sfixed32Map = 10; + map Fixed64Map = 11; + map Sfixed64Map = 12; + map BoolMap = 13; + map StringMap = 14; + map StringToBytesMap = 15; + map StringToEnumMap = 16; + map StringToMsgMap = 17; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/marshaler/mapsproto2pb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/marshaler/mapsproto2pb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..71075faf7ce710d7fd582fc53733b538dd4b5de5 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/marshaler/mapsproto2pb_test.go @@ -0,0 +1,514 @@ +// Code generated by protoc-gen-gogo. +// source: combos/marshaler/mapsproto2.proto +// DO NOT EDIT! + +/* +Package proto2_maps is a generated protocol buffer package. + +It is generated from these files: + combos/marshaler/mapsproto2.proto + +It has these top-level messages: + FloatingPoint + AllMaps +*/ +package proto2_maps + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestFloatingPointProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestFloatingPointMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkFloatingPointProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedFloatingPoint(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &FloatingPoint{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAllMapsMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAllMapsProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMaps(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AllMaps{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllMapsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestFloatingPointProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMapsproto2Description(t *testing.T) { + Mapsproto2Description() +} +func TestFloatingPointVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllMapsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestFloatingPointFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAllMapsFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestFloatingPointGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllMapsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestFloatingPointSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkFloatingPointSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAllMapsSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllMapsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/neither/mapsproto2.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/neither/mapsproto2.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..8bb7b0f4be2ea4c252fd82adec89369a2b8c253d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/neither/mapsproto2.pb.go @@ -0,0 +1,3556 @@ +// Code generated by protoc-gen-gogo. +// source: combos/neither/mapsproto2.proto +// DO NOT EDIT! + +/* +Package proto2_maps is a generated protocol buffer package. + +It is generated from these files: + combos/neither/mapsproto2.proto + +It has these top-level messages: + FloatingPoint + AllMaps +*/ +package proto2_maps + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" +import github_com_gogo_protobuf_sortkeys "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/sortkeys" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type MapEnum int32 + +const ( + MA MapEnum = 0 + MB MapEnum = 1 + MC MapEnum = 2 +) + +var MapEnum_name = map[int32]string{ + 0: "MA", + 1: "MB", + 2: "MC", +} +var MapEnum_value = map[string]int32{ + "MA": 0, + "MB": 1, + "MC": 2, +} + +func (x MapEnum) Enum() *MapEnum { + p := new(MapEnum) + *p = x + return p +} +func (x MapEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(MapEnum_name, int32(x)) +} +func (x *MapEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(MapEnum_value, data, "MapEnum") + if err != nil { + return err + } + *x = MapEnum(value) + return nil +} + +type FloatingPoint struct { + F *float64 `protobuf:"fixed64,1,opt,name=f" json:"f,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FloatingPoint) Reset() { *m = FloatingPoint{} } +func (*FloatingPoint) ProtoMessage() {} + +type AllMaps struct { + StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"` + Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"` + Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=proto2.maps.MapEnum"` + StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllMaps) Reset() { *m = AllMaps{} } +func (*AllMaps) ProtoMessage() {} + +func init() { + proto.RegisterEnum("proto2.maps.MapEnum", MapEnum_name, MapEnum_value) +} +func (this *FloatingPoint) Description() (desc *google_protobuf.FileDescriptorSet) { + return Mapsproto2Description() +} +func (this *AllMaps) Description() (desc *google_protobuf.FileDescriptorSet) { + return Mapsproto2Description() +} +func Mapsproto2Description() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/neither/mapsproto2.proto"), + Package: func(v string) *string { return &v }("proto2.maps"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FloatingPoint"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("f"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }, {Name: func(v string) *string { return &v }("AllMaps"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMap"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToDoubleMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToFloatMap"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToFloatMapEntry"), + }, {Name: func(v string) *string { return &v }("Int32Map"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Int32MapEntry"), + }, {Name: func(v string) *string { return &v }("Int64Map"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Int64MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint32Map"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Uint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint64Map"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Uint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint32Map"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint64Map"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed32Map"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Fixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed32Map"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sfixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed64Map"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Fixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed64Map"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sfixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("BoolMap"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.BoolMapEntry"), + }, {Name: func(v string) *string { return &v }("StringMap"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToBytesMap"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToBytesMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToEnumMap"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToEnumMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToMsgMap"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToMsgMapEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToFloatMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("BoolMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToBytesMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToEnumMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".proto2.maps.MapEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToMsgMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("MapEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("MA"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("MB"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("MC"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (x MapEnum) String() string { + s, ok := MapEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *FloatingPoint) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return fmt.Errorf("that is not of type *FloatingPoint") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *FloatingPointbut is not nil && this == nil") + } + if this.F != nil && that1.F != nil { + if *this.F != *that1.F { + return fmt.Errorf("F this(%v) Not Equal that(%v)", *this.F, *that1.F) + } + } else if this.F != nil { + return fmt.Errorf("this.F == nil && that.F != nil") + } else if that1.F != nil { + return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *FloatingPoint) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.F != nil && that1.F != nil { + if *this.F != *that1.F { + return false + } + } else if this.F != nil { + return false + } else if that1.F != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllMaps) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllMaps) + if !ok { + return fmt.Errorf("that is not of type *AllMaps") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllMaps but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllMapsbut is not nil && this == nil") + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap)) + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i]) + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap)) + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i]) + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map)) + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i]) + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map)) + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i]) + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map)) + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i]) + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map)) + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i]) + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map)) + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i]) + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map)) + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i]) + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map)) + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i]) + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map)) + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i]) + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map)) + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i]) + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map)) + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i]) + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap)) + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i]) + } + } + if len(this.StringMap) != len(that1.StringMap) { + return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap)) + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i]) + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap)) + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i]) + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap)) + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i]) + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap)) + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AllMaps) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllMaps) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return false + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return false + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return false + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return false + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return false + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return false + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return false + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return false + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return false + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return false + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return false + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return false + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return false + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return false + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return false + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return false + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return false + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return false + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return false + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return false + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return false + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return false + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return false + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return false + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return false + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return false + } + } + if len(this.StringMap) != len(that1.StringMap) { + return false + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return false + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return false + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return false + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return false + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return false + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return false + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} + +type FloatingPointFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetF() *float64 +} + +func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message { + return NewFloatingPointFromFace(this) +} + +func (this *FloatingPoint) GetF() *float64 { + return this.F +} + +func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint { + this := &FloatingPoint{} + this.F = that.GetF() + return this +} + +type AllMapsFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetStringToDoubleMap() map[string]float64 + GetStringToFloatMap() map[string]float32 + GetInt32Map() map[int32]int32 + GetInt64Map() map[int64]int64 + GetUint32Map() map[uint32]uint32 + GetUint64Map() map[uint64]uint64 + GetSint32Map() map[int32]int32 + GetSint64Map() map[int64]int64 + GetFixed32Map() map[uint32]uint32 + GetSfixed32Map() map[int32]int32 + GetFixed64Map() map[uint64]uint64 + GetSfixed64Map() map[int64]int64 + GetBoolMap() map[bool]bool + GetStringMap() map[string]string + GetStringToBytesMap() map[string][]byte + GetStringToEnumMap() map[string]MapEnum + GetStringToMsgMap() map[string]*FloatingPoint +} + +func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAllMapsFromFace(this) +} + +func (this *AllMaps) GetStringToDoubleMap() map[string]float64 { + return this.StringToDoubleMap +} + +func (this *AllMaps) GetStringToFloatMap() map[string]float32 { + return this.StringToFloatMap +} + +func (this *AllMaps) GetInt32Map() map[int32]int32 { + return this.Int32Map +} + +func (this *AllMaps) GetInt64Map() map[int64]int64 { + return this.Int64Map +} + +func (this *AllMaps) GetUint32Map() map[uint32]uint32 { + return this.Uint32Map +} + +func (this *AllMaps) GetUint64Map() map[uint64]uint64 { + return this.Uint64Map +} + +func (this *AllMaps) GetSint32Map() map[int32]int32 { + return this.Sint32Map +} + +func (this *AllMaps) GetSint64Map() map[int64]int64 { + return this.Sint64Map +} + +func (this *AllMaps) GetFixed32Map() map[uint32]uint32 { + return this.Fixed32Map +} + +func (this *AllMaps) GetSfixed32Map() map[int32]int32 { + return this.Sfixed32Map +} + +func (this *AllMaps) GetFixed64Map() map[uint64]uint64 { + return this.Fixed64Map +} + +func (this *AllMaps) GetSfixed64Map() map[int64]int64 { + return this.Sfixed64Map +} + +func (this *AllMaps) GetBoolMap() map[bool]bool { + return this.BoolMap +} + +func (this *AllMaps) GetStringMap() map[string]string { + return this.StringMap +} + +func (this *AllMaps) GetStringToBytesMap() map[string][]byte { + return this.StringToBytesMap +} + +func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum { + return this.StringToEnumMap +} + +func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint { + return this.StringToMsgMap +} + +func NewAllMapsFromFace(that AllMapsFace) *AllMaps { + this := &AllMaps{} + this.StringToDoubleMap = that.GetStringToDoubleMap() + this.StringToFloatMap = that.GetStringToFloatMap() + this.Int32Map = that.GetInt32Map() + this.Int64Map = that.GetInt64Map() + this.Uint32Map = that.GetUint32Map() + this.Uint64Map = that.GetUint64Map() + this.Sint32Map = that.GetSint32Map() + this.Sint64Map = that.GetSint64Map() + this.Fixed32Map = that.GetFixed32Map() + this.Sfixed32Map = that.GetSfixed32Map() + this.Fixed64Map = that.GetFixed64Map() + this.Sfixed64Map = that.GetSfixed64Map() + this.BoolMap = that.GetBoolMap() + this.StringMap = that.GetStringMap() + this.StringToBytesMap = that.GetStringToBytesMap() + this.StringToEnumMap = that.GetStringToEnumMap() + this.StringToMsgMap = that.GetStringToMsgMap() + return this +} + +func (this *FloatingPoint) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&proto2_maps.FloatingPoint{") + if this.F != nil { + s = append(s, "F: "+valueToGoStringMapsproto2(this.F, "float64")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllMaps) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 21) + s = append(s, "&proto2_maps.AllMaps{") + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + if this.StringToDoubleMap != nil { + s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n") + } + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + if this.StringToFloatMap != nil { + s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n") + } + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + if this.Int32Map != nil { + s = append(s, "Int32Map: "+mapStringForInt32Map+",\n") + } + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + if this.Int64Map != nil { + s = append(s, "Int64Map: "+mapStringForInt64Map+",\n") + } + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + if this.Uint32Map != nil { + s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n") + } + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + if this.Uint64Map != nil { + s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n") + } + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + if this.Sint32Map != nil { + s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n") + } + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + if this.Sint64Map != nil { + s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n") + } + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + if this.Fixed32Map != nil { + s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n") + } + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + if this.Sfixed32Map != nil { + s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n") + } + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + if this.Fixed64Map != nil { + s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n") + } + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + if this.Sfixed64Map != nil { + s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n") + } + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + if this.BoolMap != nil { + s = append(s, "BoolMap: "+mapStringForBoolMap+",\n") + } + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + if this.StringMap != nil { + s = append(s, "StringMap: "+mapStringForStringMap+",\n") + } + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + if this.StringToBytesMap != nil { + s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n") + } + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + if this.StringToEnumMap != nil { + s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n") + } + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + if this.StringToMsgMap != nil { + s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringMapsproto2(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringMapsproto2(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedFloatingPoint(r randyMapsproto2, easy bool) *FloatingPoint { + this := &FloatingPoint{} + if r.Intn(10) != 0 { + v1 := float64(r.Float64()) + if r.Intn(2) == 0 { + v1 *= -1 + } + this.F = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 2) + } + return this +} + +func NewPopulatedAllMaps(r randyMapsproto2, easy bool) *AllMaps { + this := &AllMaps{} + if r.Intn(10) != 0 { + v2 := r.Intn(10) + this.StringToDoubleMap = make(map[string]float64) + for i := 0; i < v2; i++ { + v3 := randStringMapsproto2(r) + this.StringToDoubleMap[v3] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.StringToDoubleMap[v3] *= -1 + } + } + } + if r.Intn(10) != 0 { + v4 := r.Intn(10) + this.StringToFloatMap = make(map[string]float32) + for i := 0; i < v4; i++ { + v5 := randStringMapsproto2(r) + this.StringToFloatMap[v5] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.StringToFloatMap[v5] *= -1 + } + } + } + if r.Intn(10) != 0 { + v6 := r.Intn(10) + this.Int32Map = make(map[int32]int32) + for i := 0; i < v6; i++ { + v7 := int32(r.Int31()) + this.Int32Map[v7] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Int32Map[v7] *= -1 + } + } + } + if r.Intn(10) != 0 { + v8 := r.Intn(10) + this.Int64Map = make(map[int64]int64) + for i := 0; i < v8; i++ { + v9 := int64(r.Int63()) + this.Int64Map[v9] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Int64Map[v9] *= -1 + } + } + } + if r.Intn(10) != 0 { + v10 := r.Intn(10) + this.Uint32Map = make(map[uint32]uint32) + for i := 0; i < v10; i++ { + v11 := uint32(r.Uint32()) + this.Uint32Map[v11] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v12 := r.Intn(10) + this.Uint64Map = make(map[uint64]uint64) + for i := 0; i < v12; i++ { + v13 := uint64(uint64(r.Uint32())) + this.Uint64Map[v13] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v14 := r.Intn(10) + this.Sint32Map = make(map[int32]int32) + for i := 0; i < v14; i++ { + v15 := int32(r.Int31()) + this.Sint32Map[v15] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sint32Map[v15] *= -1 + } + } + } + if r.Intn(10) != 0 { + v16 := r.Intn(10) + this.Sint64Map = make(map[int64]int64) + for i := 0; i < v16; i++ { + v17 := int64(r.Int63()) + this.Sint64Map[v17] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sint64Map[v17] *= -1 + } + } + } + if r.Intn(10) != 0 { + v18 := r.Intn(10) + this.Fixed32Map = make(map[uint32]uint32) + for i := 0; i < v18; i++ { + v19 := uint32(r.Uint32()) + this.Fixed32Map[v19] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v20 := r.Intn(10) + this.Sfixed32Map = make(map[int32]int32) + for i := 0; i < v20; i++ { + v21 := int32(r.Int31()) + this.Sfixed32Map[v21] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sfixed32Map[v21] *= -1 + } + } + } + if r.Intn(10) != 0 { + v22 := r.Intn(10) + this.Fixed64Map = make(map[uint64]uint64) + for i := 0; i < v22; i++ { + v23 := uint64(uint64(r.Uint32())) + this.Fixed64Map[v23] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v24 := r.Intn(10) + this.Sfixed64Map = make(map[int64]int64) + for i := 0; i < v24; i++ { + v25 := int64(r.Int63()) + this.Sfixed64Map[v25] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sfixed64Map[v25] *= -1 + } + } + } + if r.Intn(10) != 0 { + v26 := r.Intn(10) + this.BoolMap = make(map[bool]bool) + for i := 0; i < v26; i++ { + v27 := bool(bool(r.Intn(2) == 0)) + this.BoolMap[v27] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v28 := r.Intn(10) + this.StringMap = make(map[string]string) + for i := 0; i < v28; i++ { + this.StringMap[randStringMapsproto2(r)] = randStringMapsproto2(r) + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(10) + this.StringToBytesMap = make(map[string][]byte) + for i := 0; i < v29; i++ { + v30 := r.Intn(100) + v31 := randStringMapsproto2(r) + this.StringToBytesMap[v31] = make([]byte, v30) + for i := 0; i < v30; i++ { + this.StringToBytesMap[v31][i] = byte(r.Intn(256)) + } + } + } + if r.Intn(10) != 0 { + v32 := r.Intn(10) + this.StringToEnumMap = make(map[string]MapEnum) + for i := 0; i < v32; i++ { + this.StringToEnumMap[randStringMapsproto2(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if r.Intn(10) != 0 { + v33 := r.Intn(10) + this.StringToMsgMap = make(map[string]*FloatingPoint) + for i := 0; i < v33; i++ { + this.StringToMsgMap[randStringMapsproto2(r)] = NewPopulatedFloatingPoint(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 18) + } + return this +} + +type randyMapsproto2 interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneMapsproto2(r randyMapsproto2) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringMapsproto2(r randyMapsproto2) string { + v34 := r.Intn(100) + tmps := make([]rune, v34) + for i := 0; i < v34; i++ { + tmps[i] = randUTF8RuneMapsproto2(r) + } + return string(tmps) +} +func randUnrecognizedMapsproto2(r randyMapsproto2, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldMapsproto2(data, r, fieldNumber, wire) + } + return data +} +func randFieldMapsproto2(data []byte, r randyMapsproto2, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + v35 := r.Int63() + if r.Intn(2) == 0 { + v35 *= -1 + } + data = encodeVarintPopulateMapsproto2(data, uint64(v35)) + case 1: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateMapsproto2(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateMapsproto2(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *FloatingPoint) Size() (n int) { + var l int + _ = l + if m.F != nil { + n += 9 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllMaps) Size() (n int) { + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + for k, v := range m.StringToDoubleMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToFloatMap) > 0 { + for k, v := range m.StringToFloatMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Int32Map) > 0 { + for k, v := range m.Int32Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Int64Map) > 0 { + for k, v := range m.Int64Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Uint32Map) > 0 { + for k, v := range m.Uint32Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Uint64Map) > 0 { + for k, v := range m.Uint64Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sint32Map) > 0 { + for k, v := range m.Sint32Map { + _ = k + _ = v + mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sint64Map) > 0 { + for k, v := range m.Sint64Map { + _ = k + _ = v + mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Fixed32Map) > 0 { + for k, v := range m.Fixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sfixed32Map) > 0 { + for k, v := range m.Sfixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Fixed64Map) > 0 { + for k, v := range m.Fixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sfixed64Map) > 0 { + for k, v := range m.Sfixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.BoolMap) > 0 { + for k, v := range m.BoolMap { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + 1 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringMap) > 0 { + for k, v := range m.StringMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToBytesMap) > 0 { + for k, v := range m.StringToBytesMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToEnumMap) > 0 { + for k, v := range m.StringToEnumMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToMsgMap) > 0 { + for k, v := range m.StringToMsgMap { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + l + sovMapsproto2(uint64(l)) + n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovMapsproto2(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozMapsproto2(x uint64) (n int) { + return sovMapsproto2(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *FloatingPoint) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FloatingPoint{`, + `F:` + valueToStringMapsproto2(this.F) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllMaps) String() string { + if this == nil { + return "nil" + } + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]*float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]*float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]*int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]*int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]*uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]*uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]*int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]*int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]*uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]*int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]*uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]*int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]*bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]*string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]*MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + s := strings.Join([]string{`&AllMaps{`, + `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`, + `StringToFloatMap:` + mapStringForStringToFloatMap + `,`, + `Int32Map:` + mapStringForInt32Map + `,`, + `Int64Map:` + mapStringForInt64Map + `,`, + `Uint32Map:` + mapStringForUint32Map + `,`, + `Uint64Map:` + mapStringForUint64Map + `,`, + `Sint32Map:` + mapStringForSint32Map + `,`, + `Sint64Map:` + mapStringForSint64Map + `,`, + `Fixed32Map:` + mapStringForFixed32Map + `,`, + `Sfixed32Map:` + mapStringForSfixed32Map + `,`, + `Fixed64Map:` + mapStringForFixed64Map + `,`, + `Sfixed64Map:` + mapStringForSfixed64Map + `,`, + `BoolMap:` + mapStringForBoolMap + `,`, + `StringMap:` + mapStringForStringMap + `,`, + `StringToBytesMap:` + mapStringForStringToBytesMap + `,`, + `StringToEnumMap:` + mapStringForStringToEnumMap + `,`, + `StringToMsgMap:` + mapStringForStringToMsgMap + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringMapsproto2(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/neither/mapsproto2.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/neither/mapsproto2.proto new file mode 100644 index 0000000000000000000000000000000000000000..3de81b0c5390d6f74549a30a7e76df1d228d569b --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/neither/mapsproto2.proto @@ -0,0 +1,93 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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"; + +package proto2.maps; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message FloatingPoint { + optional double f = 1; +} + +enum MapEnum { + MA = 0; + MB = 1; + MC = 2; +} + +message AllMaps { + map StringToDoubleMap = 1; + map StringToFloatMap = 2; + map Int32Map = 3; + map Int64Map = 4; + map Uint32Map = 5; + map Uint64Map = 6; + map Sint32Map = 7; + map Sint64Map = 8; + map Fixed32Map = 9; + map Sfixed32Map = 10; + map Fixed64Map = 11; + map Sfixed64Map = 12; + map BoolMap = 13; + map StringMap = 14; + map StringToBytesMap = 15; + map StringToEnumMap = 16; + map StringToMsgMap = 17; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/neither/mapsproto2pb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/neither/mapsproto2pb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..93f4322e2ae50ab1374629e7cf3a5fcae75668c7 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/neither/mapsproto2pb_test.go @@ -0,0 +1,458 @@ +// Code generated by protoc-gen-gogo. +// source: combos/neither/mapsproto2.proto +// DO NOT EDIT! + +/* +Package proto2_maps is a generated protocol buffer package. + +It is generated from these files: + combos/neither/mapsproto2.proto + +It has these top-level messages: + FloatingPoint + AllMaps +*/ +package proto2_maps + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestFloatingPointProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkFloatingPointProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedFloatingPoint(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &FloatingPoint{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAllMapsProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMaps(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AllMaps{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllMapsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestFloatingPointProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMapsproto2Description(t *testing.T) { + Mapsproto2Description() +} +func TestFloatingPointVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllMapsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestFloatingPointFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAllMapsFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestFloatingPointGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllMapsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestFloatingPointSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkFloatingPointSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAllMapsSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllMapsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unmarshaler/mapsproto2.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unmarshaler/mapsproto2.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..6e9a6ce4fff6826a77a03d6c7b52420da68a2830 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unmarshaler/mapsproto2.pb.go @@ -0,0 +1,5398 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unmarshaler/mapsproto2.proto +// DO NOT EDIT! + +/* + Package proto2_maps is a generated protocol buffer package. + + It is generated from these files: + combos/unmarshaler/mapsproto2.proto + + It has these top-level messages: + FloatingPoint + AllMaps +*/ +package proto2_maps + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" +import github_com_gogo_protobuf_sortkeys "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/sortkeys" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type MapEnum int32 + +const ( + MA MapEnum = 0 + MB MapEnum = 1 + MC MapEnum = 2 +) + +var MapEnum_name = map[int32]string{ + 0: "MA", + 1: "MB", + 2: "MC", +} +var MapEnum_value = map[string]int32{ + "MA": 0, + "MB": 1, + "MC": 2, +} + +func (x MapEnum) Enum() *MapEnum { + p := new(MapEnum) + *p = x + return p +} +func (x MapEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(MapEnum_name, int32(x)) +} +func (x *MapEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(MapEnum_value, data, "MapEnum") + if err != nil { + return err + } + *x = MapEnum(value) + return nil +} + +type FloatingPoint struct { + F *float64 `protobuf:"fixed64,1,opt,name=f" json:"f,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FloatingPoint) Reset() { *m = FloatingPoint{} } +func (*FloatingPoint) ProtoMessage() {} + +type AllMaps struct { + StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"` + Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"` + Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=proto2.maps.MapEnum"` + StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllMaps) Reset() { *m = AllMaps{} } +func (*AllMaps) ProtoMessage() {} + +func init() { + proto.RegisterEnum("proto2.maps.MapEnum", MapEnum_name, MapEnum_value) +} +func (this *FloatingPoint) Description() (desc *google_protobuf.FileDescriptorSet) { + return Mapsproto2Description() +} +func (this *AllMaps) Description() (desc *google_protobuf.FileDescriptorSet) { + return Mapsproto2Description() +} +func Mapsproto2Description() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unmarshaler/mapsproto2.proto"), + Package: func(v string) *string { return &v }("proto2.maps"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FloatingPoint"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("f"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }, {Name: func(v string) *string { return &v }("AllMaps"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMap"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToDoubleMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToFloatMap"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToFloatMapEntry"), + }, {Name: func(v string) *string { return &v }("Int32Map"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Int32MapEntry"), + }, {Name: func(v string) *string { return &v }("Int64Map"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Int64MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint32Map"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Uint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint64Map"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Uint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint32Map"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint64Map"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed32Map"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Fixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed32Map"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sfixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed64Map"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Fixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed64Map"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sfixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("BoolMap"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.BoolMapEntry"), + }, {Name: func(v string) *string { return &v }("StringMap"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToBytesMap"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToBytesMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToEnumMap"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToEnumMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToMsgMap"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToMsgMapEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToFloatMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("BoolMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToBytesMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToEnumMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".proto2.maps.MapEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToMsgMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("MapEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("MA"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("MB"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("MC"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (x MapEnum) String() string { + s, ok := MapEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *FloatingPoint) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return fmt.Errorf("that is not of type *FloatingPoint") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *FloatingPointbut is not nil && this == nil") + } + if this.F != nil && that1.F != nil { + if *this.F != *that1.F { + return fmt.Errorf("F this(%v) Not Equal that(%v)", *this.F, *that1.F) + } + } else if this.F != nil { + return fmt.Errorf("this.F == nil && that.F != nil") + } else if that1.F != nil { + return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *FloatingPoint) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.F != nil && that1.F != nil { + if *this.F != *that1.F { + return false + } + } else if this.F != nil { + return false + } else if that1.F != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllMaps) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllMaps) + if !ok { + return fmt.Errorf("that is not of type *AllMaps") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllMaps but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllMapsbut is not nil && this == nil") + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap)) + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i]) + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap)) + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i]) + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map)) + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i]) + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map)) + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i]) + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map)) + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i]) + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map)) + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i]) + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map)) + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i]) + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map)) + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i]) + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map)) + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i]) + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map)) + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i]) + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map)) + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i]) + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map)) + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i]) + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap)) + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i]) + } + } + if len(this.StringMap) != len(that1.StringMap) { + return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap)) + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i]) + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap)) + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i]) + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap)) + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i]) + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap)) + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AllMaps) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllMaps) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return false + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return false + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return false + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return false + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return false + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return false + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return false + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return false + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return false + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return false + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return false + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return false + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return false + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return false + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return false + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return false + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return false + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return false + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return false + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return false + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return false + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return false + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return false + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return false + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return false + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return false + } + } + if len(this.StringMap) != len(that1.StringMap) { + return false + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return false + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return false + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return false + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return false + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return false + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return false + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} + +type FloatingPointFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetF() *float64 +} + +func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message { + return NewFloatingPointFromFace(this) +} + +func (this *FloatingPoint) GetF() *float64 { + return this.F +} + +func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint { + this := &FloatingPoint{} + this.F = that.GetF() + return this +} + +type AllMapsFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetStringToDoubleMap() map[string]float64 + GetStringToFloatMap() map[string]float32 + GetInt32Map() map[int32]int32 + GetInt64Map() map[int64]int64 + GetUint32Map() map[uint32]uint32 + GetUint64Map() map[uint64]uint64 + GetSint32Map() map[int32]int32 + GetSint64Map() map[int64]int64 + GetFixed32Map() map[uint32]uint32 + GetSfixed32Map() map[int32]int32 + GetFixed64Map() map[uint64]uint64 + GetSfixed64Map() map[int64]int64 + GetBoolMap() map[bool]bool + GetStringMap() map[string]string + GetStringToBytesMap() map[string][]byte + GetStringToEnumMap() map[string]MapEnum + GetStringToMsgMap() map[string]*FloatingPoint +} + +func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAllMapsFromFace(this) +} + +func (this *AllMaps) GetStringToDoubleMap() map[string]float64 { + return this.StringToDoubleMap +} + +func (this *AllMaps) GetStringToFloatMap() map[string]float32 { + return this.StringToFloatMap +} + +func (this *AllMaps) GetInt32Map() map[int32]int32 { + return this.Int32Map +} + +func (this *AllMaps) GetInt64Map() map[int64]int64 { + return this.Int64Map +} + +func (this *AllMaps) GetUint32Map() map[uint32]uint32 { + return this.Uint32Map +} + +func (this *AllMaps) GetUint64Map() map[uint64]uint64 { + return this.Uint64Map +} + +func (this *AllMaps) GetSint32Map() map[int32]int32 { + return this.Sint32Map +} + +func (this *AllMaps) GetSint64Map() map[int64]int64 { + return this.Sint64Map +} + +func (this *AllMaps) GetFixed32Map() map[uint32]uint32 { + return this.Fixed32Map +} + +func (this *AllMaps) GetSfixed32Map() map[int32]int32 { + return this.Sfixed32Map +} + +func (this *AllMaps) GetFixed64Map() map[uint64]uint64 { + return this.Fixed64Map +} + +func (this *AllMaps) GetSfixed64Map() map[int64]int64 { + return this.Sfixed64Map +} + +func (this *AllMaps) GetBoolMap() map[bool]bool { + return this.BoolMap +} + +func (this *AllMaps) GetStringMap() map[string]string { + return this.StringMap +} + +func (this *AllMaps) GetStringToBytesMap() map[string][]byte { + return this.StringToBytesMap +} + +func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum { + return this.StringToEnumMap +} + +func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint { + return this.StringToMsgMap +} + +func NewAllMapsFromFace(that AllMapsFace) *AllMaps { + this := &AllMaps{} + this.StringToDoubleMap = that.GetStringToDoubleMap() + this.StringToFloatMap = that.GetStringToFloatMap() + this.Int32Map = that.GetInt32Map() + this.Int64Map = that.GetInt64Map() + this.Uint32Map = that.GetUint32Map() + this.Uint64Map = that.GetUint64Map() + this.Sint32Map = that.GetSint32Map() + this.Sint64Map = that.GetSint64Map() + this.Fixed32Map = that.GetFixed32Map() + this.Sfixed32Map = that.GetSfixed32Map() + this.Fixed64Map = that.GetFixed64Map() + this.Sfixed64Map = that.GetSfixed64Map() + this.BoolMap = that.GetBoolMap() + this.StringMap = that.GetStringMap() + this.StringToBytesMap = that.GetStringToBytesMap() + this.StringToEnumMap = that.GetStringToEnumMap() + this.StringToMsgMap = that.GetStringToMsgMap() + return this +} + +func (this *FloatingPoint) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&proto2_maps.FloatingPoint{") + if this.F != nil { + s = append(s, "F: "+valueToGoStringMapsproto2(this.F, "float64")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllMaps) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 21) + s = append(s, "&proto2_maps.AllMaps{") + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + if this.StringToDoubleMap != nil { + s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n") + } + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + if this.StringToFloatMap != nil { + s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n") + } + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + if this.Int32Map != nil { + s = append(s, "Int32Map: "+mapStringForInt32Map+",\n") + } + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + if this.Int64Map != nil { + s = append(s, "Int64Map: "+mapStringForInt64Map+",\n") + } + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + if this.Uint32Map != nil { + s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n") + } + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + if this.Uint64Map != nil { + s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n") + } + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + if this.Sint32Map != nil { + s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n") + } + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + if this.Sint64Map != nil { + s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n") + } + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + if this.Fixed32Map != nil { + s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n") + } + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + if this.Sfixed32Map != nil { + s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n") + } + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + if this.Fixed64Map != nil { + s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n") + } + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + if this.Sfixed64Map != nil { + s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n") + } + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + if this.BoolMap != nil { + s = append(s, "BoolMap: "+mapStringForBoolMap+",\n") + } + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + if this.StringMap != nil { + s = append(s, "StringMap: "+mapStringForStringMap+",\n") + } + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + if this.StringToBytesMap != nil { + s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n") + } + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + if this.StringToEnumMap != nil { + s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n") + } + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + if this.StringToMsgMap != nil { + s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringMapsproto2(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringMapsproto2(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedFloatingPoint(r randyMapsproto2, easy bool) *FloatingPoint { + this := &FloatingPoint{} + if r.Intn(10) != 0 { + v1 := float64(r.Float64()) + if r.Intn(2) == 0 { + v1 *= -1 + } + this.F = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 2) + } + return this +} + +func NewPopulatedAllMaps(r randyMapsproto2, easy bool) *AllMaps { + this := &AllMaps{} + if r.Intn(10) != 0 { + v2 := r.Intn(10) + this.StringToDoubleMap = make(map[string]float64) + for i := 0; i < v2; i++ { + v3 := randStringMapsproto2(r) + this.StringToDoubleMap[v3] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.StringToDoubleMap[v3] *= -1 + } + } + } + if r.Intn(10) != 0 { + v4 := r.Intn(10) + this.StringToFloatMap = make(map[string]float32) + for i := 0; i < v4; i++ { + v5 := randStringMapsproto2(r) + this.StringToFloatMap[v5] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.StringToFloatMap[v5] *= -1 + } + } + } + if r.Intn(10) != 0 { + v6 := r.Intn(10) + this.Int32Map = make(map[int32]int32) + for i := 0; i < v6; i++ { + v7 := int32(r.Int31()) + this.Int32Map[v7] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Int32Map[v7] *= -1 + } + } + } + if r.Intn(10) != 0 { + v8 := r.Intn(10) + this.Int64Map = make(map[int64]int64) + for i := 0; i < v8; i++ { + v9 := int64(r.Int63()) + this.Int64Map[v9] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Int64Map[v9] *= -1 + } + } + } + if r.Intn(10) != 0 { + v10 := r.Intn(10) + this.Uint32Map = make(map[uint32]uint32) + for i := 0; i < v10; i++ { + v11 := uint32(r.Uint32()) + this.Uint32Map[v11] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v12 := r.Intn(10) + this.Uint64Map = make(map[uint64]uint64) + for i := 0; i < v12; i++ { + v13 := uint64(uint64(r.Uint32())) + this.Uint64Map[v13] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v14 := r.Intn(10) + this.Sint32Map = make(map[int32]int32) + for i := 0; i < v14; i++ { + v15 := int32(r.Int31()) + this.Sint32Map[v15] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sint32Map[v15] *= -1 + } + } + } + if r.Intn(10) != 0 { + v16 := r.Intn(10) + this.Sint64Map = make(map[int64]int64) + for i := 0; i < v16; i++ { + v17 := int64(r.Int63()) + this.Sint64Map[v17] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sint64Map[v17] *= -1 + } + } + } + if r.Intn(10) != 0 { + v18 := r.Intn(10) + this.Fixed32Map = make(map[uint32]uint32) + for i := 0; i < v18; i++ { + v19 := uint32(r.Uint32()) + this.Fixed32Map[v19] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v20 := r.Intn(10) + this.Sfixed32Map = make(map[int32]int32) + for i := 0; i < v20; i++ { + v21 := int32(r.Int31()) + this.Sfixed32Map[v21] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sfixed32Map[v21] *= -1 + } + } + } + if r.Intn(10) != 0 { + v22 := r.Intn(10) + this.Fixed64Map = make(map[uint64]uint64) + for i := 0; i < v22; i++ { + v23 := uint64(uint64(r.Uint32())) + this.Fixed64Map[v23] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v24 := r.Intn(10) + this.Sfixed64Map = make(map[int64]int64) + for i := 0; i < v24; i++ { + v25 := int64(r.Int63()) + this.Sfixed64Map[v25] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sfixed64Map[v25] *= -1 + } + } + } + if r.Intn(10) != 0 { + v26 := r.Intn(10) + this.BoolMap = make(map[bool]bool) + for i := 0; i < v26; i++ { + v27 := bool(bool(r.Intn(2) == 0)) + this.BoolMap[v27] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v28 := r.Intn(10) + this.StringMap = make(map[string]string) + for i := 0; i < v28; i++ { + this.StringMap[randStringMapsproto2(r)] = randStringMapsproto2(r) + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(10) + this.StringToBytesMap = make(map[string][]byte) + for i := 0; i < v29; i++ { + v30 := r.Intn(100) + v31 := randStringMapsproto2(r) + this.StringToBytesMap[v31] = make([]byte, v30) + for i := 0; i < v30; i++ { + this.StringToBytesMap[v31][i] = byte(r.Intn(256)) + } + } + } + if r.Intn(10) != 0 { + v32 := r.Intn(10) + this.StringToEnumMap = make(map[string]MapEnum) + for i := 0; i < v32; i++ { + this.StringToEnumMap[randStringMapsproto2(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if r.Intn(10) != 0 { + v33 := r.Intn(10) + this.StringToMsgMap = make(map[string]*FloatingPoint) + for i := 0; i < v33; i++ { + this.StringToMsgMap[randStringMapsproto2(r)] = NewPopulatedFloatingPoint(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 18) + } + return this +} + +type randyMapsproto2 interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneMapsproto2(r randyMapsproto2) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringMapsproto2(r randyMapsproto2) string { + v34 := r.Intn(100) + tmps := make([]rune, v34) + for i := 0; i < v34; i++ { + tmps[i] = randUTF8RuneMapsproto2(r) + } + return string(tmps) +} +func randUnrecognizedMapsproto2(r randyMapsproto2, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldMapsproto2(data, r, fieldNumber, wire) + } + return data +} +func randFieldMapsproto2(data []byte, r randyMapsproto2, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + v35 := r.Int63() + if r.Intn(2) == 0 { + v35 *= -1 + } + data = encodeVarintPopulateMapsproto2(data, uint64(v35)) + case 1: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateMapsproto2(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateMapsproto2(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *FloatingPoint) Size() (n int) { + var l int + _ = l + if m.F != nil { + n += 9 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllMaps) Size() (n int) { + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + for k, v := range m.StringToDoubleMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToFloatMap) > 0 { + for k, v := range m.StringToFloatMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Int32Map) > 0 { + for k, v := range m.Int32Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Int64Map) > 0 { + for k, v := range m.Int64Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Uint32Map) > 0 { + for k, v := range m.Uint32Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Uint64Map) > 0 { + for k, v := range m.Uint64Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sint32Map) > 0 { + for k, v := range m.Sint32Map { + _ = k + _ = v + mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sint64Map) > 0 { + for k, v := range m.Sint64Map { + _ = k + _ = v + mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Fixed32Map) > 0 { + for k, v := range m.Fixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sfixed32Map) > 0 { + for k, v := range m.Sfixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Fixed64Map) > 0 { + for k, v := range m.Fixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sfixed64Map) > 0 { + for k, v := range m.Sfixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.BoolMap) > 0 { + for k, v := range m.BoolMap { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + 1 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringMap) > 0 { + for k, v := range m.StringMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToBytesMap) > 0 { + for k, v := range m.StringToBytesMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToEnumMap) > 0 { + for k, v := range m.StringToEnumMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToMsgMap) > 0 { + for k, v := range m.StringToMsgMap { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + l + sovMapsproto2(uint64(l)) + n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovMapsproto2(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozMapsproto2(x uint64) (n int) { + return sovMapsproto2(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *FloatingPoint) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FloatingPoint{`, + `F:` + valueToStringMapsproto2(this.F) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllMaps) String() string { + if this == nil { + return "nil" + } + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]*float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]*float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]*int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]*int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]*uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]*uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]*int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]*int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]*uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]*int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]*uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]*int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]*bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]*string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]*MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + s := strings.Join([]string{`&AllMaps{`, + `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`, + `StringToFloatMap:` + mapStringForStringToFloatMap + `,`, + `Int32Map:` + mapStringForInt32Map + `,`, + `Int64Map:` + mapStringForInt64Map + `,`, + `Uint32Map:` + mapStringForUint32Map + `,`, + `Uint64Map:` + mapStringForUint64Map + `,`, + `Sint32Map:` + mapStringForSint32Map + `,`, + `Sint64Map:` + mapStringForSint64Map + `,`, + `Fixed32Map:` + mapStringForFixed32Map + `,`, + `Sfixed32Map:` + mapStringForSfixed32Map + `,`, + `Fixed64Map:` + mapStringForFixed64Map + `,`, + `Sfixed64Map:` + mapStringForSfixed64Map + `,`, + `BoolMap:` + mapStringForBoolMap + `,`, + `StringMap:` + mapStringForStringMap + `,`, + `StringToBytesMap:` + mapStringForStringToBytesMap + `,`, + `StringToEnumMap:` + mapStringForStringToEnumMap + `,`, + `StringToMsgMap:` + mapStringForStringToMsgMap + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringMapsproto2(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *FloatingPoint) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FloatingPoint: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FloatingPoint: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field F", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.F = &v2 + default: + iNdEx = preIndex + skippy, err := skipMapsproto2(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthMapsproto2 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AllMaps) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AllMaps: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AllMaps: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvaluetemp = uint64(data[iNdEx-8]) + mapvaluetemp |= uint64(data[iNdEx-7]) << 8 + mapvaluetemp |= uint64(data[iNdEx-6]) << 16 + mapvaluetemp |= uint64(data[iNdEx-5]) << 24 + mapvaluetemp |= uint64(data[iNdEx-4]) << 32 + mapvaluetemp |= uint64(data[iNdEx-3]) << 40 + mapvaluetemp |= uint64(data[iNdEx-2]) << 48 + mapvaluetemp |= uint64(data[iNdEx-1]) << 56 + mapvalue := math.Float64frombits(mapvaluetemp) + if m.StringToDoubleMap == nil { + m.StringToDoubleMap = make(map[string]float64) + } + m.StringToDoubleMap[mapkey] = mapvalue + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvaluetemp = uint32(data[iNdEx-4]) + mapvaluetemp |= uint32(data[iNdEx-3]) << 8 + mapvaluetemp |= uint32(data[iNdEx-2]) << 16 + mapvaluetemp |= uint32(data[iNdEx-1]) << 24 + mapvalue := math.Float32frombits(mapvaluetemp) + if m.StringToFloatMap == nil { + m.StringToFloatMap = make(map[string]float32) + } + m.StringToFloatMap[mapkey] = mapvalue + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Int32Map == nil { + m.Int32Map = make(map[int32]int32) + } + m.Int32Map[mapkey] = mapvalue + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Int64Map == nil { + m.Int64Map = make(map[int64]int64) + } + m.Int64Map[mapkey] = mapvalue + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Uint32Map == nil { + m.Uint32Map = make(map[uint32]uint32) + } + m.Uint32Map[mapkey] = mapvalue + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Uint64Map == nil { + m.Uint64Map = make(map[uint64]uint64) + } + m.Uint64Map[mapkey] = mapvalue + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31)) + mapkey := int32(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31)) + mapvalue := int32(mapvaluetemp) + if m.Sint32Map == nil { + m.Sint32Map = make(map[int32]int32) + } + m.Sint32Map[mapkey] = mapvalue + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63) + mapkey := int64(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63) + mapvalue := int64(mapvaluetemp) + if m.Sint64Map == nil { + m.Sint64Map = make(map[int64]int64) + } + m.Sint64Map[mapkey] = mapvalue + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapkey = uint32(data[iNdEx-4]) + mapkey |= uint32(data[iNdEx-3]) << 8 + mapkey |= uint32(data[iNdEx-2]) << 16 + mapkey |= uint32(data[iNdEx-1]) << 24 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvalue = uint32(data[iNdEx-4]) + mapvalue |= uint32(data[iNdEx-3]) << 8 + mapvalue |= uint32(data[iNdEx-2]) << 16 + mapvalue |= uint32(data[iNdEx-1]) << 24 + if m.Fixed32Map == nil { + m.Fixed32Map = make(map[uint32]uint32) + } + m.Fixed32Map[mapkey] = mapvalue + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapkey = int32(data[iNdEx-4]) + mapkey |= int32(data[iNdEx-3]) << 8 + mapkey |= int32(data[iNdEx-2]) << 16 + mapkey |= int32(data[iNdEx-1]) << 24 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvalue = int32(data[iNdEx-4]) + mapvalue |= int32(data[iNdEx-3]) << 8 + mapvalue |= int32(data[iNdEx-2]) << 16 + mapvalue |= int32(data[iNdEx-1]) << 24 + if m.Sfixed32Map == nil { + m.Sfixed32Map = make(map[int32]int32) + } + m.Sfixed32Map[mapkey] = mapvalue + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapkey = uint64(data[iNdEx-8]) + mapkey |= uint64(data[iNdEx-7]) << 8 + mapkey |= uint64(data[iNdEx-6]) << 16 + mapkey |= uint64(data[iNdEx-5]) << 24 + mapkey |= uint64(data[iNdEx-4]) << 32 + mapkey |= uint64(data[iNdEx-3]) << 40 + mapkey |= uint64(data[iNdEx-2]) << 48 + mapkey |= uint64(data[iNdEx-1]) << 56 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvalue = uint64(data[iNdEx-8]) + mapvalue |= uint64(data[iNdEx-7]) << 8 + mapvalue |= uint64(data[iNdEx-6]) << 16 + mapvalue |= uint64(data[iNdEx-5]) << 24 + mapvalue |= uint64(data[iNdEx-4]) << 32 + mapvalue |= uint64(data[iNdEx-3]) << 40 + mapvalue |= uint64(data[iNdEx-2]) << 48 + mapvalue |= uint64(data[iNdEx-1]) << 56 + if m.Fixed64Map == nil { + m.Fixed64Map = make(map[uint64]uint64) + } + m.Fixed64Map[mapkey] = mapvalue + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapkey = int64(data[iNdEx-8]) + mapkey |= int64(data[iNdEx-7]) << 8 + mapkey |= int64(data[iNdEx-6]) << 16 + mapkey |= int64(data[iNdEx-5]) << 24 + mapkey |= int64(data[iNdEx-4]) << 32 + mapkey |= int64(data[iNdEx-3]) << 40 + mapkey |= int64(data[iNdEx-2]) << 48 + mapkey |= int64(data[iNdEx-1]) << 56 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvalue = int64(data[iNdEx-8]) + mapvalue |= int64(data[iNdEx-7]) << 8 + mapvalue |= int64(data[iNdEx-6]) << 16 + mapvalue |= int64(data[iNdEx-5]) << 24 + mapvalue |= int64(data[iNdEx-4]) << 32 + mapvalue |= int64(data[iNdEx-3]) << 40 + mapvalue |= int64(data[iNdEx-2]) << 48 + mapvalue |= int64(data[iNdEx-1]) << 56 + if m.Sfixed64Map == nil { + m.Sfixed64Map = make(map[int64]int64) + } + m.Sfixed64Map[mapkey] = mapvalue + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkey := bool(mapkeytemp != 0) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvalue := bool(mapvaluetemp != 0) + if m.BoolMap == nil { + m.BoolMap = make(map[bool]bool) + } + m.BoolMap[mapkey] = mapvalue + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthMapsproto2 + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue := string(data[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + if m.StringMap == nil { + m.StringMap = make(map[string]string) + } + m.StringMap[mapkey] = mapvalue + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapbyteLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthMapsproto2 + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := make([]byte, mapbyteLen) + copy(mapvalue, data[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + if m.StringToBytesMap == nil { + m.StringToBytesMap = make(map[string][]byte) + } + m.StringToBytesMap[mapkey] = mapvalue + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue MapEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (MapEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.StringToEnumMap == nil { + m.StringToEnumMap = make(map[string]MapEnum) + } + m.StringToEnumMap[mapkey] = mapvalue + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthMapsproto2 + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthMapsproto2 + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &FloatingPoint{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.StringToMsgMap == nil { + m.StringToMsgMap = make(map[string]*FloatingPoint) + } + m.StringToMsgMap[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipMapsproto2(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthMapsproto2 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipMapsproto2(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthMapsproto2 + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMapsproto2 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipMapsproto2(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthMapsproto2 = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowMapsproto2 = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unmarshaler/mapsproto2.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unmarshaler/mapsproto2.proto new file mode 100644 index 0000000000000000000000000000000000000000..a96a89711fd3c27bc154cd5e76fbaffedc414d6a --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unmarshaler/mapsproto2.proto @@ -0,0 +1,93 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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"; + +package proto2.maps; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message FloatingPoint { + optional double f = 1; +} + +enum MapEnum { + MA = 0; + MB = 1; + MC = 2; +} + +message AllMaps { + map StringToDoubleMap = 1; + map StringToFloatMap = 2; + map Int32Map = 3; + map Int64Map = 4; + map Uint32Map = 5; + map Uint64Map = 6; + map Sint32Map = 7; + map Sint64Map = 8; + map Fixed32Map = 9; + map Sfixed32Map = 10; + map Fixed64Map = 11; + map Sfixed64Map = 12; + map BoolMap = 13; + map StringMap = 14; + map StringToBytesMap = 15; + map StringToEnumMap = 16; + map StringToMsgMap = 17; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unmarshaler/mapsproto2pb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unmarshaler/mapsproto2pb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..a6e4ff0c6acf3adc0f9ad7ef6ef9a37db5545912 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unmarshaler/mapsproto2pb_test.go @@ -0,0 +1,458 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unmarshaler/mapsproto2.proto +// DO NOT EDIT! + +/* +Package proto2_maps is a generated protocol buffer package. + +It is generated from these files: + combos/unmarshaler/mapsproto2.proto + +It has these top-level messages: + FloatingPoint + AllMaps +*/ +package proto2_maps + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestFloatingPointProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkFloatingPointProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedFloatingPoint(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &FloatingPoint{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAllMapsProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMaps(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AllMaps{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllMapsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestFloatingPointProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMapsproto2Description(t *testing.T) { + Mapsproto2Description() +} +func TestFloatingPointVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllMapsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestFloatingPointFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAllMapsFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestFloatingPointGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllMapsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestFloatingPointSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkFloatingPointSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAllMapsSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllMapsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeboth/mapsproto2.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeboth/mapsproto2.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..8432b8aaa957c47283ec65a9fb31f5ee42bf8b29 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeboth/mapsproto2.pb.go @@ -0,0 +1,5839 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeboth/mapsproto2.proto +// DO NOT EDIT! + +/* + Package proto2_maps is a generated protocol buffer package. + + It is generated from these files: + combos/unsafeboth/mapsproto2.proto + + It has these top-level messages: + FloatingPoint + AllMaps +*/ +package proto2_maps + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" +import github_com_gogo_protobuf_sortkeys "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/sortkeys" + +import unsafe "unsafe" +import errors "errors" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type MapEnum int32 + +const ( + MA MapEnum = 0 + MB MapEnum = 1 + MC MapEnum = 2 +) + +var MapEnum_name = map[int32]string{ + 0: "MA", + 1: "MB", + 2: "MC", +} +var MapEnum_value = map[string]int32{ + "MA": 0, + "MB": 1, + "MC": 2, +} + +func (x MapEnum) Enum() *MapEnum { + p := new(MapEnum) + *p = x + return p +} +func (x MapEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(MapEnum_name, int32(x)) +} +func (x *MapEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(MapEnum_value, data, "MapEnum") + if err != nil { + return err + } + *x = MapEnum(value) + return nil +} + +type FloatingPoint struct { + F *float64 `protobuf:"fixed64,1,opt,name=f" json:"f,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FloatingPoint) Reset() { *m = FloatingPoint{} } +func (*FloatingPoint) ProtoMessage() {} + +type AllMaps struct { + StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"` + Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"` + Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=proto2.maps.MapEnum"` + StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllMaps) Reset() { *m = AllMaps{} } +func (*AllMaps) ProtoMessage() {} + +func init() { + proto.RegisterEnum("proto2.maps.MapEnum", MapEnum_name, MapEnum_value) +} +func (this *FloatingPoint) Description() (desc *google_protobuf.FileDescriptorSet) { + return Mapsproto2Description() +} +func (this *AllMaps) Description() (desc *google_protobuf.FileDescriptorSet) { + return Mapsproto2Description() +} +func Mapsproto2Description() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unsafeboth/mapsproto2.proto"), + Package: func(v string) *string { return &v }("proto2.maps"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FloatingPoint"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("f"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }, {Name: func(v string) *string { return &v }("AllMaps"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMap"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToDoubleMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToFloatMap"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToFloatMapEntry"), + }, {Name: func(v string) *string { return &v }("Int32Map"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Int32MapEntry"), + }, {Name: func(v string) *string { return &v }("Int64Map"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Int64MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint32Map"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Uint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint64Map"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Uint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint32Map"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint64Map"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed32Map"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Fixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed32Map"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sfixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed64Map"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Fixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed64Map"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sfixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("BoolMap"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.BoolMapEntry"), + }, {Name: func(v string) *string { return &v }("StringMap"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToBytesMap"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToBytesMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToEnumMap"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToEnumMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToMsgMap"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToMsgMapEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToFloatMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("BoolMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToBytesMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToEnumMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".proto2.maps.MapEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToMsgMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("MapEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("MA"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("MB"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("MC"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x1}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x1})}}, + }}, + } +} +func (x MapEnum) String() string { + s, ok := MapEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *FloatingPoint) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return fmt.Errorf("that is not of type *FloatingPoint") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *FloatingPointbut is not nil && this == nil") + } + if this.F != nil && that1.F != nil { + if *this.F != *that1.F { + return fmt.Errorf("F this(%v) Not Equal that(%v)", *this.F, *that1.F) + } + } else if this.F != nil { + return fmt.Errorf("this.F == nil && that.F != nil") + } else if that1.F != nil { + return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *FloatingPoint) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.F != nil && that1.F != nil { + if *this.F != *that1.F { + return false + } + } else if this.F != nil { + return false + } else if that1.F != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllMaps) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllMaps) + if !ok { + return fmt.Errorf("that is not of type *AllMaps") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllMaps but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllMapsbut is not nil && this == nil") + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap)) + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i]) + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap)) + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i]) + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map)) + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i]) + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map)) + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i]) + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map)) + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i]) + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map)) + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i]) + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map)) + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i]) + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map)) + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i]) + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map)) + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i]) + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map)) + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i]) + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map)) + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i]) + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map)) + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i]) + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap)) + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i]) + } + } + if len(this.StringMap) != len(that1.StringMap) { + return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap)) + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i]) + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap)) + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i]) + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap)) + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i]) + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap)) + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AllMaps) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllMaps) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return false + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return false + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return false + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return false + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return false + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return false + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return false + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return false + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return false + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return false + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return false + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return false + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return false + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return false + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return false + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return false + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return false + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return false + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return false + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return false + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return false + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return false + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return false + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return false + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return false + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return false + } + } + if len(this.StringMap) != len(that1.StringMap) { + return false + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return false + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return false + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return false + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return false + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return false + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return false + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} + +type FloatingPointFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetF() *float64 +} + +func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message { + return NewFloatingPointFromFace(this) +} + +func (this *FloatingPoint) GetF() *float64 { + return this.F +} + +func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint { + this := &FloatingPoint{} + this.F = that.GetF() + return this +} + +type AllMapsFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetStringToDoubleMap() map[string]float64 + GetStringToFloatMap() map[string]float32 + GetInt32Map() map[int32]int32 + GetInt64Map() map[int64]int64 + GetUint32Map() map[uint32]uint32 + GetUint64Map() map[uint64]uint64 + GetSint32Map() map[int32]int32 + GetSint64Map() map[int64]int64 + GetFixed32Map() map[uint32]uint32 + GetSfixed32Map() map[int32]int32 + GetFixed64Map() map[uint64]uint64 + GetSfixed64Map() map[int64]int64 + GetBoolMap() map[bool]bool + GetStringMap() map[string]string + GetStringToBytesMap() map[string][]byte + GetStringToEnumMap() map[string]MapEnum + GetStringToMsgMap() map[string]*FloatingPoint +} + +func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAllMapsFromFace(this) +} + +func (this *AllMaps) GetStringToDoubleMap() map[string]float64 { + return this.StringToDoubleMap +} + +func (this *AllMaps) GetStringToFloatMap() map[string]float32 { + return this.StringToFloatMap +} + +func (this *AllMaps) GetInt32Map() map[int32]int32 { + return this.Int32Map +} + +func (this *AllMaps) GetInt64Map() map[int64]int64 { + return this.Int64Map +} + +func (this *AllMaps) GetUint32Map() map[uint32]uint32 { + return this.Uint32Map +} + +func (this *AllMaps) GetUint64Map() map[uint64]uint64 { + return this.Uint64Map +} + +func (this *AllMaps) GetSint32Map() map[int32]int32 { + return this.Sint32Map +} + +func (this *AllMaps) GetSint64Map() map[int64]int64 { + return this.Sint64Map +} + +func (this *AllMaps) GetFixed32Map() map[uint32]uint32 { + return this.Fixed32Map +} + +func (this *AllMaps) GetSfixed32Map() map[int32]int32 { + return this.Sfixed32Map +} + +func (this *AllMaps) GetFixed64Map() map[uint64]uint64 { + return this.Fixed64Map +} + +func (this *AllMaps) GetSfixed64Map() map[int64]int64 { + return this.Sfixed64Map +} + +func (this *AllMaps) GetBoolMap() map[bool]bool { + return this.BoolMap +} + +func (this *AllMaps) GetStringMap() map[string]string { + return this.StringMap +} + +func (this *AllMaps) GetStringToBytesMap() map[string][]byte { + return this.StringToBytesMap +} + +func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum { + return this.StringToEnumMap +} + +func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint { + return this.StringToMsgMap +} + +func NewAllMapsFromFace(that AllMapsFace) *AllMaps { + this := &AllMaps{} + this.StringToDoubleMap = that.GetStringToDoubleMap() + this.StringToFloatMap = that.GetStringToFloatMap() + this.Int32Map = that.GetInt32Map() + this.Int64Map = that.GetInt64Map() + this.Uint32Map = that.GetUint32Map() + this.Uint64Map = that.GetUint64Map() + this.Sint32Map = that.GetSint32Map() + this.Sint64Map = that.GetSint64Map() + this.Fixed32Map = that.GetFixed32Map() + this.Sfixed32Map = that.GetSfixed32Map() + this.Fixed64Map = that.GetFixed64Map() + this.Sfixed64Map = that.GetSfixed64Map() + this.BoolMap = that.GetBoolMap() + this.StringMap = that.GetStringMap() + this.StringToBytesMap = that.GetStringToBytesMap() + this.StringToEnumMap = that.GetStringToEnumMap() + this.StringToMsgMap = that.GetStringToMsgMap() + return this +} + +func (this *FloatingPoint) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&proto2_maps.FloatingPoint{") + if this.F != nil { + s = append(s, "F: "+valueToGoStringMapsproto2(this.F, "float64")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllMaps) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 21) + s = append(s, "&proto2_maps.AllMaps{") + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + if this.StringToDoubleMap != nil { + s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n") + } + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + if this.StringToFloatMap != nil { + s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n") + } + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + if this.Int32Map != nil { + s = append(s, "Int32Map: "+mapStringForInt32Map+",\n") + } + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + if this.Int64Map != nil { + s = append(s, "Int64Map: "+mapStringForInt64Map+",\n") + } + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + if this.Uint32Map != nil { + s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n") + } + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + if this.Uint64Map != nil { + s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n") + } + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + if this.Sint32Map != nil { + s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n") + } + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + if this.Sint64Map != nil { + s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n") + } + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + if this.Fixed32Map != nil { + s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n") + } + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + if this.Sfixed32Map != nil { + s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n") + } + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + if this.Fixed64Map != nil { + s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n") + } + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + if this.Sfixed64Map != nil { + s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n") + } + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + if this.BoolMap != nil { + s = append(s, "BoolMap: "+mapStringForBoolMap+",\n") + } + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + if this.StringMap != nil { + s = append(s, "StringMap: "+mapStringForStringMap+",\n") + } + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + if this.StringToBytesMap != nil { + s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n") + } + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + if this.StringToEnumMap != nil { + s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n") + } + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + if this.StringToMsgMap != nil { + s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringMapsproto2(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringMapsproto2(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedFloatingPoint(r randyMapsproto2, easy bool) *FloatingPoint { + this := &FloatingPoint{} + if r.Intn(10) != 0 { + v1 := float64(r.Float64()) + if r.Intn(2) == 0 { + v1 *= -1 + } + this.F = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 2) + } + return this +} + +func NewPopulatedAllMaps(r randyMapsproto2, easy bool) *AllMaps { + this := &AllMaps{} + if r.Intn(10) != 0 { + v2 := r.Intn(10) + this.StringToDoubleMap = make(map[string]float64) + for i := 0; i < v2; i++ { + v3 := randStringMapsproto2(r) + this.StringToDoubleMap[v3] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.StringToDoubleMap[v3] *= -1 + } + } + } + if r.Intn(10) != 0 { + v4 := r.Intn(10) + this.StringToFloatMap = make(map[string]float32) + for i := 0; i < v4; i++ { + v5 := randStringMapsproto2(r) + this.StringToFloatMap[v5] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.StringToFloatMap[v5] *= -1 + } + } + } + if r.Intn(10) != 0 { + v6 := r.Intn(10) + this.Int32Map = make(map[int32]int32) + for i := 0; i < v6; i++ { + v7 := int32(r.Int31()) + this.Int32Map[v7] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Int32Map[v7] *= -1 + } + } + } + if r.Intn(10) != 0 { + v8 := r.Intn(10) + this.Int64Map = make(map[int64]int64) + for i := 0; i < v8; i++ { + v9 := int64(r.Int63()) + this.Int64Map[v9] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Int64Map[v9] *= -1 + } + } + } + if r.Intn(10) != 0 { + v10 := r.Intn(10) + this.Uint32Map = make(map[uint32]uint32) + for i := 0; i < v10; i++ { + v11 := uint32(r.Uint32()) + this.Uint32Map[v11] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v12 := r.Intn(10) + this.Uint64Map = make(map[uint64]uint64) + for i := 0; i < v12; i++ { + v13 := uint64(uint64(r.Uint32())) + this.Uint64Map[v13] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v14 := r.Intn(10) + this.Sint32Map = make(map[int32]int32) + for i := 0; i < v14; i++ { + v15 := int32(r.Int31()) + this.Sint32Map[v15] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sint32Map[v15] *= -1 + } + } + } + if r.Intn(10) != 0 { + v16 := r.Intn(10) + this.Sint64Map = make(map[int64]int64) + for i := 0; i < v16; i++ { + v17 := int64(r.Int63()) + this.Sint64Map[v17] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sint64Map[v17] *= -1 + } + } + } + if r.Intn(10) != 0 { + v18 := r.Intn(10) + this.Fixed32Map = make(map[uint32]uint32) + for i := 0; i < v18; i++ { + v19 := uint32(r.Uint32()) + this.Fixed32Map[v19] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v20 := r.Intn(10) + this.Sfixed32Map = make(map[int32]int32) + for i := 0; i < v20; i++ { + v21 := int32(r.Int31()) + this.Sfixed32Map[v21] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sfixed32Map[v21] *= -1 + } + } + } + if r.Intn(10) != 0 { + v22 := r.Intn(10) + this.Fixed64Map = make(map[uint64]uint64) + for i := 0; i < v22; i++ { + v23 := uint64(uint64(r.Uint32())) + this.Fixed64Map[v23] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v24 := r.Intn(10) + this.Sfixed64Map = make(map[int64]int64) + for i := 0; i < v24; i++ { + v25 := int64(r.Int63()) + this.Sfixed64Map[v25] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sfixed64Map[v25] *= -1 + } + } + } + if r.Intn(10) != 0 { + v26 := r.Intn(10) + this.BoolMap = make(map[bool]bool) + for i := 0; i < v26; i++ { + v27 := bool(bool(r.Intn(2) == 0)) + this.BoolMap[v27] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v28 := r.Intn(10) + this.StringMap = make(map[string]string) + for i := 0; i < v28; i++ { + this.StringMap[randStringMapsproto2(r)] = randStringMapsproto2(r) + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(10) + this.StringToBytesMap = make(map[string][]byte) + for i := 0; i < v29; i++ { + v30 := r.Intn(100) + v31 := randStringMapsproto2(r) + this.StringToBytesMap[v31] = make([]byte, v30) + for i := 0; i < v30; i++ { + this.StringToBytesMap[v31][i] = byte(r.Intn(256)) + } + } + } + if r.Intn(10) != 0 { + v32 := r.Intn(10) + this.StringToEnumMap = make(map[string]MapEnum) + for i := 0; i < v32; i++ { + this.StringToEnumMap[randStringMapsproto2(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if r.Intn(10) != 0 { + v33 := r.Intn(10) + this.StringToMsgMap = make(map[string]*FloatingPoint) + for i := 0; i < v33; i++ { + this.StringToMsgMap[randStringMapsproto2(r)] = NewPopulatedFloatingPoint(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 18) + } + return this +} + +type randyMapsproto2 interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneMapsproto2(r randyMapsproto2) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringMapsproto2(r randyMapsproto2) string { + v34 := r.Intn(100) + tmps := make([]rune, v34) + for i := 0; i < v34; i++ { + tmps[i] = randUTF8RuneMapsproto2(r) + } + return string(tmps) +} +func randUnrecognizedMapsproto2(r randyMapsproto2, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldMapsproto2(data, r, fieldNumber, wire) + } + return data +} +func randFieldMapsproto2(data []byte, r randyMapsproto2, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + v35 := r.Int63() + if r.Intn(2) == 0 { + v35 *= -1 + } + data = encodeVarintPopulateMapsproto2(data, uint64(v35)) + case 1: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateMapsproto2(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateMapsproto2(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *FloatingPoint) Size() (n int) { + var l int + _ = l + if m.F != nil { + n += 9 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllMaps) Size() (n int) { + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + for k, v := range m.StringToDoubleMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToFloatMap) > 0 { + for k, v := range m.StringToFloatMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Int32Map) > 0 { + for k, v := range m.Int32Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Int64Map) > 0 { + for k, v := range m.Int64Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Uint32Map) > 0 { + for k, v := range m.Uint32Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Uint64Map) > 0 { + for k, v := range m.Uint64Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sint32Map) > 0 { + for k, v := range m.Sint32Map { + _ = k + _ = v + mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sint64Map) > 0 { + for k, v := range m.Sint64Map { + _ = k + _ = v + mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Fixed32Map) > 0 { + for k, v := range m.Fixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sfixed32Map) > 0 { + for k, v := range m.Sfixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Fixed64Map) > 0 { + for k, v := range m.Fixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sfixed64Map) > 0 { + for k, v := range m.Sfixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.BoolMap) > 0 { + for k, v := range m.BoolMap { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + 1 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringMap) > 0 { + for k, v := range m.StringMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToBytesMap) > 0 { + for k, v := range m.StringToBytesMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToEnumMap) > 0 { + for k, v := range m.StringToEnumMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToMsgMap) > 0 { + for k, v := range m.StringToMsgMap { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + l + sovMapsproto2(uint64(l)) + n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovMapsproto2(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozMapsproto2(x uint64) (n int) { + return sovMapsproto2(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *FloatingPoint) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FloatingPoint{`, + `F:` + valueToStringMapsproto2(this.F) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllMaps) String() string { + if this == nil { + return "nil" + } + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]*float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]*float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]*int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]*int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]*uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]*uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]*int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]*int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]*uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]*int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]*uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]*int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]*bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]*string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]*MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + s := strings.Join([]string{`&AllMaps{`, + `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`, + `StringToFloatMap:` + mapStringForStringToFloatMap + `,`, + `Int32Map:` + mapStringForInt32Map + `,`, + `Int64Map:` + mapStringForInt64Map + `,`, + `Uint32Map:` + mapStringForUint32Map + `,`, + `Uint64Map:` + mapStringForUint64Map + `,`, + `Sint32Map:` + mapStringForSint32Map + `,`, + `Sint64Map:` + mapStringForSint64Map + `,`, + `Fixed32Map:` + mapStringForFixed32Map + `,`, + `Sfixed32Map:` + mapStringForSfixed32Map + `,`, + `Fixed64Map:` + mapStringForFixed64Map + `,`, + `Sfixed64Map:` + mapStringForSfixed64Map + `,`, + `BoolMap:` + mapStringForBoolMap + `,`, + `StringMap:` + mapStringForStringMap + `,`, + `StringToBytesMap:` + mapStringForStringToBytesMap + `,`, + `StringToEnumMap:` + mapStringForStringToEnumMap + `,`, + `StringToMsgMap:` + mapStringForStringToMsgMap + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringMapsproto2(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *FloatingPoint) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *FloatingPoint) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.F != nil { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = *m.F + i += 8 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AllMaps) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AllMaps) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + keysForStringToDoubleMap := make([]string, 0, len(m.StringToDoubleMap)) + for k := range m.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + for _, k := range keysForStringToDoubleMap { + data[i] = 0xa + i++ + v := m.StringToDoubleMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 8 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x11 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(math.Float64bits(v))) + } + } + if len(m.StringToFloatMap) > 0 { + keysForStringToFloatMap := make([]string, 0, len(m.StringToFloatMap)) + for k := range m.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + for _, k := range keysForStringToFloatMap { + data[i] = 0x12 + i++ + v := m.StringToFloatMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 4 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x15 + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(math.Float32bits(v))) + } + } + if len(m.Int32Map) > 0 { + keysForInt32Map := make([]int32, 0, len(m.Int32Map)) + for k := range m.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + for _, k := range keysForInt32Map { + data[i] = 0x1a + i++ + v := m.Int32Map[k] + mapSize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.Int64Map) > 0 { + keysForInt64Map := make([]int64, 0, len(m.Int64Map)) + for k := range m.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + for _, k := range keysForInt64Map { + data[i] = 0x22 + i++ + v := m.Int64Map[k] + mapSize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.Uint32Map) > 0 { + keysForUint32Map := make([]uint32, 0, len(m.Uint32Map)) + for k := range m.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + for _, k := range keysForUint32Map { + data[i] = 0x2a + i++ + v := m.Uint32Map[k] + mapSize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.Uint64Map) > 0 { + keysForUint64Map := make([]uint64, 0, len(m.Uint64Map)) + for k := range m.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + for _, k := range keysForUint64Map { + data[i] = 0x32 + i++ + v := m.Uint64Map[k] + mapSize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.Sint32Map) > 0 { + keysForSint32Map := make([]int32, 0, len(m.Sint32Map)) + for k := range m.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + for _, k := range keysForSint32Map { + data[i] = 0x3a + i++ + v := m.Sint32Map[k] + mapSize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64((uint32(k)<<1)^uint32((k>>31)))) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64((uint32(v)<<1)^uint32((v>>31)))) + } + } + if len(m.Sint64Map) > 0 { + keysForSint64Map := make([]int64, 0, len(m.Sint64Map)) + for k := range m.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + for _, k := range keysForSint64Map { + data[i] = 0x42 + i++ + v := m.Sint64Map[k] + mapSize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64((uint64(k)<<1)^uint64((k>>63)))) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64((uint64(v)<<1)^uint64((v>>63)))) + } + } + if len(m.Fixed32Map) > 0 { + keysForFixed32Map := make([]uint32, 0, len(m.Fixed32Map)) + for k := range m.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + for _, k := range keysForFixed32Map { + data[i] = 0x4a + i++ + v := m.Fixed32Map[k] + mapSize := 1 + 4 + 1 + 4 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xd + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(k)) + data[i] = 0x15 + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(v)) + } + } + if len(m.Sfixed32Map) > 0 { + keysForSfixed32Map := make([]int32, 0, len(m.Sfixed32Map)) + for k := range m.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + for _, k := range keysForSfixed32Map { + data[i] = 0x52 + i++ + v := m.Sfixed32Map[k] + mapSize := 1 + 4 + 1 + 4 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xd + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(k)) + data[i] = 0x15 + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(v)) + } + } + if len(m.Fixed64Map) > 0 { + keysForFixed64Map := make([]uint64, 0, len(m.Fixed64Map)) + for k := range m.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + for _, k := range keysForFixed64Map { + data[i] = 0x5a + i++ + v := m.Fixed64Map[k] + mapSize := 1 + 8 + 1 + 8 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x9 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(k)) + data[i] = 0x11 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(v)) + } + } + if len(m.Sfixed64Map) > 0 { + keysForSfixed64Map := make([]int64, 0, len(m.Sfixed64Map)) + for k := range m.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + for _, k := range keysForSfixed64Map { + data[i] = 0x62 + i++ + v := m.Sfixed64Map[k] + mapSize := 1 + 8 + 1 + 8 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x9 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(k)) + data[i] = 0x11 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(v)) + } + } + if len(m.BoolMap) > 0 { + keysForBoolMap := make([]bool, 0, len(m.BoolMap)) + for k := range m.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + for _, k := range keysForBoolMap { + data[i] = 0x6a + i++ + v := m.BoolMap[k] + mapSize := 1 + 1 + 1 + 1 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + if k { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x10 + i++ + if v { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.StringMap) > 0 { + keysForStringMap := make([]string, 0, len(m.StringMap)) + for k := range m.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + for _, k := range keysForStringMap { + data[i] = 0x72 + i++ + v := m.StringMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.StringToBytesMap) > 0 { + keysForStringToBytesMap := make([]string, 0, len(m.StringToBytesMap)) + for k := range m.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + for _, k := range keysForStringToBytesMap { + data[i] = 0x7a + i++ + v := m.StringToBytesMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.StringToEnumMap) > 0 { + keysForStringToEnumMap := make([]string, 0, len(m.StringToEnumMap)) + for k := range m.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + for _, k := range keysForStringToEnumMap { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + v := m.StringToEnumMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.StringToMsgMap) > 0 { + keysForStringToMsgMap := make([]string, 0, len(m.StringToMsgMap)) + for k := range m.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + for _, k := range keysForStringToMsgMap { + data[i] = 0x8a + i++ + data[i] = 0x1 + i++ + v := m.StringToMsgMap[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + msgSize + sovMapsproto2(uint64(msgSize)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v.Size())) + n1, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n1 + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Mapsproto2(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Mapsproto2(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintMapsproto2(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *FloatingPoint) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FloatingPoint: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FloatingPoint: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field F", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.F = &v + default: + iNdEx = preIndex + skippy, err := skipMapsproto2Unsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AllMaps) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AllMaps: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AllMaps: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvaluetemp = uint64(data[iNdEx-8]) + mapvaluetemp |= uint64(data[iNdEx-7]) << 8 + mapvaluetemp |= uint64(data[iNdEx-6]) << 16 + mapvaluetemp |= uint64(data[iNdEx-5]) << 24 + mapvaluetemp |= uint64(data[iNdEx-4]) << 32 + mapvaluetemp |= uint64(data[iNdEx-3]) << 40 + mapvaluetemp |= uint64(data[iNdEx-2]) << 48 + mapvaluetemp |= uint64(data[iNdEx-1]) << 56 + mapvalue := math.Float64frombits(mapvaluetemp) + if m.StringToDoubleMap == nil { + m.StringToDoubleMap = make(map[string]float64) + } + m.StringToDoubleMap[mapkey] = mapvalue + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvaluetemp = uint32(data[iNdEx-4]) + mapvaluetemp |= uint32(data[iNdEx-3]) << 8 + mapvaluetemp |= uint32(data[iNdEx-2]) << 16 + mapvaluetemp |= uint32(data[iNdEx-1]) << 24 + mapvalue := math.Float32frombits(mapvaluetemp) + if m.StringToFloatMap == nil { + m.StringToFloatMap = make(map[string]float32) + } + m.StringToFloatMap[mapkey] = mapvalue + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Int32Map == nil { + m.Int32Map = make(map[int32]int32) + } + m.Int32Map[mapkey] = mapvalue + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Int64Map == nil { + m.Int64Map = make(map[int64]int64) + } + m.Int64Map[mapkey] = mapvalue + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Uint32Map == nil { + m.Uint32Map = make(map[uint32]uint32) + } + m.Uint32Map[mapkey] = mapvalue + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Uint64Map == nil { + m.Uint64Map = make(map[uint64]uint64) + } + m.Uint64Map[mapkey] = mapvalue + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31)) + mapkey := int32(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31)) + mapvalue := int32(mapvaluetemp) + if m.Sint32Map == nil { + m.Sint32Map = make(map[int32]int32) + } + m.Sint32Map[mapkey] = mapvalue + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63) + mapkey := int64(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63) + mapvalue := int64(mapvaluetemp) + if m.Sint64Map == nil { + m.Sint64Map = make(map[int64]int64) + } + m.Sint64Map[mapkey] = mapvalue + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapkey = uint32(data[iNdEx-4]) + mapkey |= uint32(data[iNdEx-3]) << 8 + mapkey |= uint32(data[iNdEx-2]) << 16 + mapkey |= uint32(data[iNdEx-1]) << 24 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvalue = uint32(data[iNdEx-4]) + mapvalue |= uint32(data[iNdEx-3]) << 8 + mapvalue |= uint32(data[iNdEx-2]) << 16 + mapvalue |= uint32(data[iNdEx-1]) << 24 + if m.Fixed32Map == nil { + m.Fixed32Map = make(map[uint32]uint32) + } + m.Fixed32Map[mapkey] = mapvalue + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapkey = int32(data[iNdEx-4]) + mapkey |= int32(data[iNdEx-3]) << 8 + mapkey |= int32(data[iNdEx-2]) << 16 + mapkey |= int32(data[iNdEx-1]) << 24 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvalue = int32(data[iNdEx-4]) + mapvalue |= int32(data[iNdEx-3]) << 8 + mapvalue |= int32(data[iNdEx-2]) << 16 + mapvalue |= int32(data[iNdEx-1]) << 24 + if m.Sfixed32Map == nil { + m.Sfixed32Map = make(map[int32]int32) + } + m.Sfixed32Map[mapkey] = mapvalue + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapkey = uint64(data[iNdEx-8]) + mapkey |= uint64(data[iNdEx-7]) << 8 + mapkey |= uint64(data[iNdEx-6]) << 16 + mapkey |= uint64(data[iNdEx-5]) << 24 + mapkey |= uint64(data[iNdEx-4]) << 32 + mapkey |= uint64(data[iNdEx-3]) << 40 + mapkey |= uint64(data[iNdEx-2]) << 48 + mapkey |= uint64(data[iNdEx-1]) << 56 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvalue = uint64(data[iNdEx-8]) + mapvalue |= uint64(data[iNdEx-7]) << 8 + mapvalue |= uint64(data[iNdEx-6]) << 16 + mapvalue |= uint64(data[iNdEx-5]) << 24 + mapvalue |= uint64(data[iNdEx-4]) << 32 + mapvalue |= uint64(data[iNdEx-3]) << 40 + mapvalue |= uint64(data[iNdEx-2]) << 48 + mapvalue |= uint64(data[iNdEx-1]) << 56 + if m.Fixed64Map == nil { + m.Fixed64Map = make(map[uint64]uint64) + } + m.Fixed64Map[mapkey] = mapvalue + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapkey = int64(data[iNdEx-8]) + mapkey |= int64(data[iNdEx-7]) << 8 + mapkey |= int64(data[iNdEx-6]) << 16 + mapkey |= int64(data[iNdEx-5]) << 24 + mapkey |= int64(data[iNdEx-4]) << 32 + mapkey |= int64(data[iNdEx-3]) << 40 + mapkey |= int64(data[iNdEx-2]) << 48 + mapkey |= int64(data[iNdEx-1]) << 56 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvalue = int64(data[iNdEx-8]) + mapvalue |= int64(data[iNdEx-7]) << 8 + mapvalue |= int64(data[iNdEx-6]) << 16 + mapvalue |= int64(data[iNdEx-5]) << 24 + mapvalue |= int64(data[iNdEx-4]) << 32 + mapvalue |= int64(data[iNdEx-3]) << 40 + mapvalue |= int64(data[iNdEx-2]) << 48 + mapvalue |= int64(data[iNdEx-1]) << 56 + if m.Sfixed64Map == nil { + m.Sfixed64Map = make(map[int64]int64) + } + m.Sfixed64Map[mapkey] = mapvalue + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkey := bool(mapkeytemp != 0) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvalue := bool(mapvaluetemp != 0) + if m.BoolMap == nil { + m.BoolMap = make(map[bool]bool) + } + m.BoolMap[mapkey] = mapvalue + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue := string(data[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + if m.StringMap == nil { + m.StringMap = make(map[string]string) + } + m.StringMap[mapkey] = mapvalue + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapbyteLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := make([]byte, mapbyteLen) + copy(mapvalue, data[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + if m.StringToBytesMap == nil { + m.StringToBytesMap = make(map[string][]byte) + } + m.StringToBytesMap[mapkey] = mapvalue + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue MapEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (MapEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.StringToEnumMap == nil { + m.StringToEnumMap = make(map[string]MapEnum) + } + m.StringToEnumMap[mapkey] = mapvalue + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &FloatingPoint{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.StringToMsgMap == nil { + m.StringToMsgMap = make(map[string]*FloatingPoint) + } + m.StringToMsgMap[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipMapsproto2Unsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipMapsproto2Unsafe(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthMapsproto2Unsafe + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipMapsproto2Unsafe(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthMapsproto2Unsafe = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowMapsproto2Unsafe = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeboth/mapsproto2.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeboth/mapsproto2.proto new file mode 100644 index 0000000000000000000000000000000000000000..808804de51f8edb8035e9c058aea1e45a59a6eea --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeboth/mapsproto2.proto @@ -0,0 +1,93 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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"; + +package proto2.maps; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = true; +option (gogoproto.unsafe_unmarshaler_all) = true; + +message FloatingPoint { + optional double f = 1; +} + +enum MapEnum { + MA = 0; + MB = 1; + MC = 2; +} + +message AllMaps { + map StringToDoubleMap = 1; + map StringToFloatMap = 2; + map Int32Map = 3; + map Int64Map = 4; + map Uint32Map = 5; + map Uint64Map = 6; + map Sint32Map = 7; + map Sint64Map = 8; + map Fixed32Map = 9; + map Sfixed32Map = 10; + map Fixed64Map = 11; + map Sfixed64Map = 12; + map BoolMap = 13; + map StringMap = 14; + map StringToBytesMap = 15; + map StringToEnumMap = 16; + map StringToMsgMap = 17; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeboth/mapsproto2pb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeboth/mapsproto2pb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..0c8aa46d1b0a12868e72c2064204e7ebf41c31de --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeboth/mapsproto2pb_test.go @@ -0,0 +1,514 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeboth/mapsproto2.proto +// DO NOT EDIT! + +/* +Package proto2_maps is a generated protocol buffer package. + +It is generated from these files: + combos/unsafeboth/mapsproto2.proto + +It has these top-level messages: + FloatingPoint + AllMaps +*/ +package proto2_maps + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestFloatingPointProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestFloatingPointMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkFloatingPointProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedFloatingPoint(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &FloatingPoint{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAllMapsMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAllMapsProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMaps(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AllMaps{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllMapsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestFloatingPointProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMapsproto2Description(t *testing.T) { + Mapsproto2Description() +} +func TestFloatingPointVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllMapsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestFloatingPointFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAllMapsFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestFloatingPointGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllMapsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestFloatingPointSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkFloatingPointSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAllMapsSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllMapsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafemarshaler/mapsproto2.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafemarshaler/mapsproto2.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..2ac69da9d49c6cda2d3688499d776c93cbd19f53 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafemarshaler/mapsproto2.pb.go @@ -0,0 +1,4005 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafemarshaler/mapsproto2.proto +// DO NOT EDIT! + +/* +Package proto2_maps is a generated protocol buffer package. + +It is generated from these files: + combos/unsafemarshaler/mapsproto2.proto + +It has these top-level messages: + FloatingPoint + AllMaps +*/ +package proto2_maps + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" +import github_com_gogo_protobuf_sortkeys "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/sortkeys" + +import unsafe "unsafe" +import errors "errors" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type MapEnum int32 + +const ( + MA MapEnum = 0 + MB MapEnum = 1 + MC MapEnum = 2 +) + +var MapEnum_name = map[int32]string{ + 0: "MA", + 1: "MB", + 2: "MC", +} +var MapEnum_value = map[string]int32{ + "MA": 0, + "MB": 1, + "MC": 2, +} + +func (x MapEnum) Enum() *MapEnum { + p := new(MapEnum) + *p = x + return p +} +func (x MapEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(MapEnum_name, int32(x)) +} +func (x *MapEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(MapEnum_value, data, "MapEnum") + if err != nil { + return err + } + *x = MapEnum(value) + return nil +} + +type FloatingPoint struct { + F *float64 `protobuf:"fixed64,1,opt,name=f" json:"f,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FloatingPoint) Reset() { *m = FloatingPoint{} } +func (*FloatingPoint) ProtoMessage() {} + +type AllMaps struct { + StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"` + Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"` + Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=proto2.maps.MapEnum"` + StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllMaps) Reset() { *m = AllMaps{} } +func (*AllMaps) ProtoMessage() {} + +func init() { + proto.RegisterEnum("proto2.maps.MapEnum", MapEnum_name, MapEnum_value) +} +func (this *FloatingPoint) Description() (desc *google_protobuf.FileDescriptorSet) { + return Mapsproto2Description() +} +func (this *AllMaps) Description() (desc *google_protobuf.FileDescriptorSet) { + return Mapsproto2Description() +} +func Mapsproto2Description() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unsafemarshaler/mapsproto2.proto"), + Package: func(v string) *string { return &v }("proto2.maps"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FloatingPoint"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("f"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }, {Name: func(v string) *string { return &v }("AllMaps"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMap"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToDoubleMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToFloatMap"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToFloatMapEntry"), + }, {Name: func(v string) *string { return &v }("Int32Map"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Int32MapEntry"), + }, {Name: func(v string) *string { return &v }("Int64Map"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Int64MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint32Map"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Uint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint64Map"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Uint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint32Map"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint64Map"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed32Map"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Fixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed32Map"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sfixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed64Map"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Fixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed64Map"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sfixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("BoolMap"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.BoolMapEntry"), + }, {Name: func(v string) *string { return &v }("StringMap"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToBytesMap"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToBytesMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToEnumMap"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToEnumMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToMsgMap"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToMsgMapEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToFloatMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("BoolMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToBytesMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToEnumMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".proto2.maps.MapEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToMsgMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("MapEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("MA"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("MB"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("MC"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x1}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (x MapEnum) String() string { + s, ok := MapEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *FloatingPoint) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return fmt.Errorf("that is not of type *FloatingPoint") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *FloatingPointbut is not nil && this == nil") + } + if this.F != nil && that1.F != nil { + if *this.F != *that1.F { + return fmt.Errorf("F this(%v) Not Equal that(%v)", *this.F, *that1.F) + } + } else if this.F != nil { + return fmt.Errorf("this.F == nil && that.F != nil") + } else if that1.F != nil { + return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *FloatingPoint) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.F != nil && that1.F != nil { + if *this.F != *that1.F { + return false + } + } else if this.F != nil { + return false + } else if that1.F != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllMaps) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllMaps) + if !ok { + return fmt.Errorf("that is not of type *AllMaps") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllMaps but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllMapsbut is not nil && this == nil") + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap)) + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i]) + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap)) + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i]) + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map)) + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i]) + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map)) + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i]) + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map)) + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i]) + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map)) + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i]) + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map)) + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i]) + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map)) + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i]) + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map)) + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i]) + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map)) + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i]) + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map)) + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i]) + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map)) + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i]) + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap)) + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i]) + } + } + if len(this.StringMap) != len(that1.StringMap) { + return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap)) + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i]) + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap)) + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i]) + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap)) + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i]) + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap)) + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AllMaps) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllMaps) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return false + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return false + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return false + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return false + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return false + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return false + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return false + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return false + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return false + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return false + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return false + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return false + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return false + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return false + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return false + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return false + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return false + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return false + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return false + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return false + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return false + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return false + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return false + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return false + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return false + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return false + } + } + if len(this.StringMap) != len(that1.StringMap) { + return false + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return false + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return false + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return false + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return false + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return false + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return false + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} + +type FloatingPointFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetF() *float64 +} + +func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message { + return NewFloatingPointFromFace(this) +} + +func (this *FloatingPoint) GetF() *float64 { + return this.F +} + +func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint { + this := &FloatingPoint{} + this.F = that.GetF() + return this +} + +type AllMapsFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetStringToDoubleMap() map[string]float64 + GetStringToFloatMap() map[string]float32 + GetInt32Map() map[int32]int32 + GetInt64Map() map[int64]int64 + GetUint32Map() map[uint32]uint32 + GetUint64Map() map[uint64]uint64 + GetSint32Map() map[int32]int32 + GetSint64Map() map[int64]int64 + GetFixed32Map() map[uint32]uint32 + GetSfixed32Map() map[int32]int32 + GetFixed64Map() map[uint64]uint64 + GetSfixed64Map() map[int64]int64 + GetBoolMap() map[bool]bool + GetStringMap() map[string]string + GetStringToBytesMap() map[string][]byte + GetStringToEnumMap() map[string]MapEnum + GetStringToMsgMap() map[string]*FloatingPoint +} + +func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAllMapsFromFace(this) +} + +func (this *AllMaps) GetStringToDoubleMap() map[string]float64 { + return this.StringToDoubleMap +} + +func (this *AllMaps) GetStringToFloatMap() map[string]float32 { + return this.StringToFloatMap +} + +func (this *AllMaps) GetInt32Map() map[int32]int32 { + return this.Int32Map +} + +func (this *AllMaps) GetInt64Map() map[int64]int64 { + return this.Int64Map +} + +func (this *AllMaps) GetUint32Map() map[uint32]uint32 { + return this.Uint32Map +} + +func (this *AllMaps) GetUint64Map() map[uint64]uint64 { + return this.Uint64Map +} + +func (this *AllMaps) GetSint32Map() map[int32]int32 { + return this.Sint32Map +} + +func (this *AllMaps) GetSint64Map() map[int64]int64 { + return this.Sint64Map +} + +func (this *AllMaps) GetFixed32Map() map[uint32]uint32 { + return this.Fixed32Map +} + +func (this *AllMaps) GetSfixed32Map() map[int32]int32 { + return this.Sfixed32Map +} + +func (this *AllMaps) GetFixed64Map() map[uint64]uint64 { + return this.Fixed64Map +} + +func (this *AllMaps) GetSfixed64Map() map[int64]int64 { + return this.Sfixed64Map +} + +func (this *AllMaps) GetBoolMap() map[bool]bool { + return this.BoolMap +} + +func (this *AllMaps) GetStringMap() map[string]string { + return this.StringMap +} + +func (this *AllMaps) GetStringToBytesMap() map[string][]byte { + return this.StringToBytesMap +} + +func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum { + return this.StringToEnumMap +} + +func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint { + return this.StringToMsgMap +} + +func NewAllMapsFromFace(that AllMapsFace) *AllMaps { + this := &AllMaps{} + this.StringToDoubleMap = that.GetStringToDoubleMap() + this.StringToFloatMap = that.GetStringToFloatMap() + this.Int32Map = that.GetInt32Map() + this.Int64Map = that.GetInt64Map() + this.Uint32Map = that.GetUint32Map() + this.Uint64Map = that.GetUint64Map() + this.Sint32Map = that.GetSint32Map() + this.Sint64Map = that.GetSint64Map() + this.Fixed32Map = that.GetFixed32Map() + this.Sfixed32Map = that.GetSfixed32Map() + this.Fixed64Map = that.GetFixed64Map() + this.Sfixed64Map = that.GetSfixed64Map() + this.BoolMap = that.GetBoolMap() + this.StringMap = that.GetStringMap() + this.StringToBytesMap = that.GetStringToBytesMap() + this.StringToEnumMap = that.GetStringToEnumMap() + this.StringToMsgMap = that.GetStringToMsgMap() + return this +} + +func (this *FloatingPoint) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&proto2_maps.FloatingPoint{") + if this.F != nil { + s = append(s, "F: "+valueToGoStringMapsproto2(this.F, "float64")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllMaps) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 21) + s = append(s, "&proto2_maps.AllMaps{") + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + if this.StringToDoubleMap != nil { + s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n") + } + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + if this.StringToFloatMap != nil { + s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n") + } + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + if this.Int32Map != nil { + s = append(s, "Int32Map: "+mapStringForInt32Map+",\n") + } + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + if this.Int64Map != nil { + s = append(s, "Int64Map: "+mapStringForInt64Map+",\n") + } + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + if this.Uint32Map != nil { + s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n") + } + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + if this.Uint64Map != nil { + s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n") + } + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + if this.Sint32Map != nil { + s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n") + } + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + if this.Sint64Map != nil { + s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n") + } + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + if this.Fixed32Map != nil { + s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n") + } + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + if this.Sfixed32Map != nil { + s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n") + } + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + if this.Fixed64Map != nil { + s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n") + } + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + if this.Sfixed64Map != nil { + s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n") + } + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + if this.BoolMap != nil { + s = append(s, "BoolMap: "+mapStringForBoolMap+",\n") + } + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + if this.StringMap != nil { + s = append(s, "StringMap: "+mapStringForStringMap+",\n") + } + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + if this.StringToBytesMap != nil { + s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n") + } + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + if this.StringToEnumMap != nil { + s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n") + } + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + if this.StringToMsgMap != nil { + s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringMapsproto2(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringMapsproto2(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedFloatingPoint(r randyMapsproto2, easy bool) *FloatingPoint { + this := &FloatingPoint{} + if r.Intn(10) != 0 { + v1 := float64(r.Float64()) + if r.Intn(2) == 0 { + v1 *= -1 + } + this.F = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 2) + } + return this +} + +func NewPopulatedAllMaps(r randyMapsproto2, easy bool) *AllMaps { + this := &AllMaps{} + if r.Intn(10) != 0 { + v2 := r.Intn(10) + this.StringToDoubleMap = make(map[string]float64) + for i := 0; i < v2; i++ { + v3 := randStringMapsproto2(r) + this.StringToDoubleMap[v3] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.StringToDoubleMap[v3] *= -1 + } + } + } + if r.Intn(10) != 0 { + v4 := r.Intn(10) + this.StringToFloatMap = make(map[string]float32) + for i := 0; i < v4; i++ { + v5 := randStringMapsproto2(r) + this.StringToFloatMap[v5] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.StringToFloatMap[v5] *= -1 + } + } + } + if r.Intn(10) != 0 { + v6 := r.Intn(10) + this.Int32Map = make(map[int32]int32) + for i := 0; i < v6; i++ { + v7 := int32(r.Int31()) + this.Int32Map[v7] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Int32Map[v7] *= -1 + } + } + } + if r.Intn(10) != 0 { + v8 := r.Intn(10) + this.Int64Map = make(map[int64]int64) + for i := 0; i < v8; i++ { + v9 := int64(r.Int63()) + this.Int64Map[v9] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Int64Map[v9] *= -1 + } + } + } + if r.Intn(10) != 0 { + v10 := r.Intn(10) + this.Uint32Map = make(map[uint32]uint32) + for i := 0; i < v10; i++ { + v11 := uint32(r.Uint32()) + this.Uint32Map[v11] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v12 := r.Intn(10) + this.Uint64Map = make(map[uint64]uint64) + for i := 0; i < v12; i++ { + v13 := uint64(uint64(r.Uint32())) + this.Uint64Map[v13] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v14 := r.Intn(10) + this.Sint32Map = make(map[int32]int32) + for i := 0; i < v14; i++ { + v15 := int32(r.Int31()) + this.Sint32Map[v15] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sint32Map[v15] *= -1 + } + } + } + if r.Intn(10) != 0 { + v16 := r.Intn(10) + this.Sint64Map = make(map[int64]int64) + for i := 0; i < v16; i++ { + v17 := int64(r.Int63()) + this.Sint64Map[v17] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sint64Map[v17] *= -1 + } + } + } + if r.Intn(10) != 0 { + v18 := r.Intn(10) + this.Fixed32Map = make(map[uint32]uint32) + for i := 0; i < v18; i++ { + v19 := uint32(r.Uint32()) + this.Fixed32Map[v19] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v20 := r.Intn(10) + this.Sfixed32Map = make(map[int32]int32) + for i := 0; i < v20; i++ { + v21 := int32(r.Int31()) + this.Sfixed32Map[v21] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sfixed32Map[v21] *= -1 + } + } + } + if r.Intn(10) != 0 { + v22 := r.Intn(10) + this.Fixed64Map = make(map[uint64]uint64) + for i := 0; i < v22; i++ { + v23 := uint64(uint64(r.Uint32())) + this.Fixed64Map[v23] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v24 := r.Intn(10) + this.Sfixed64Map = make(map[int64]int64) + for i := 0; i < v24; i++ { + v25 := int64(r.Int63()) + this.Sfixed64Map[v25] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sfixed64Map[v25] *= -1 + } + } + } + if r.Intn(10) != 0 { + v26 := r.Intn(10) + this.BoolMap = make(map[bool]bool) + for i := 0; i < v26; i++ { + v27 := bool(bool(r.Intn(2) == 0)) + this.BoolMap[v27] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v28 := r.Intn(10) + this.StringMap = make(map[string]string) + for i := 0; i < v28; i++ { + this.StringMap[randStringMapsproto2(r)] = randStringMapsproto2(r) + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(10) + this.StringToBytesMap = make(map[string][]byte) + for i := 0; i < v29; i++ { + v30 := r.Intn(100) + v31 := randStringMapsproto2(r) + this.StringToBytesMap[v31] = make([]byte, v30) + for i := 0; i < v30; i++ { + this.StringToBytesMap[v31][i] = byte(r.Intn(256)) + } + } + } + if r.Intn(10) != 0 { + v32 := r.Intn(10) + this.StringToEnumMap = make(map[string]MapEnum) + for i := 0; i < v32; i++ { + this.StringToEnumMap[randStringMapsproto2(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if r.Intn(10) != 0 { + v33 := r.Intn(10) + this.StringToMsgMap = make(map[string]*FloatingPoint) + for i := 0; i < v33; i++ { + this.StringToMsgMap[randStringMapsproto2(r)] = NewPopulatedFloatingPoint(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 18) + } + return this +} + +type randyMapsproto2 interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneMapsproto2(r randyMapsproto2) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringMapsproto2(r randyMapsproto2) string { + v34 := r.Intn(100) + tmps := make([]rune, v34) + for i := 0; i < v34; i++ { + tmps[i] = randUTF8RuneMapsproto2(r) + } + return string(tmps) +} +func randUnrecognizedMapsproto2(r randyMapsproto2, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldMapsproto2(data, r, fieldNumber, wire) + } + return data +} +func randFieldMapsproto2(data []byte, r randyMapsproto2, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + v35 := r.Int63() + if r.Intn(2) == 0 { + v35 *= -1 + } + data = encodeVarintPopulateMapsproto2(data, uint64(v35)) + case 1: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateMapsproto2(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateMapsproto2(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *FloatingPoint) Size() (n int) { + var l int + _ = l + if m.F != nil { + n += 9 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllMaps) Size() (n int) { + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + for k, v := range m.StringToDoubleMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToFloatMap) > 0 { + for k, v := range m.StringToFloatMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Int32Map) > 0 { + for k, v := range m.Int32Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Int64Map) > 0 { + for k, v := range m.Int64Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Uint32Map) > 0 { + for k, v := range m.Uint32Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Uint64Map) > 0 { + for k, v := range m.Uint64Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sint32Map) > 0 { + for k, v := range m.Sint32Map { + _ = k + _ = v + mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sint64Map) > 0 { + for k, v := range m.Sint64Map { + _ = k + _ = v + mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Fixed32Map) > 0 { + for k, v := range m.Fixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sfixed32Map) > 0 { + for k, v := range m.Sfixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Fixed64Map) > 0 { + for k, v := range m.Fixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sfixed64Map) > 0 { + for k, v := range m.Sfixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.BoolMap) > 0 { + for k, v := range m.BoolMap { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + 1 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringMap) > 0 { + for k, v := range m.StringMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToBytesMap) > 0 { + for k, v := range m.StringToBytesMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToEnumMap) > 0 { + for k, v := range m.StringToEnumMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToMsgMap) > 0 { + for k, v := range m.StringToMsgMap { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + l + sovMapsproto2(uint64(l)) + n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovMapsproto2(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozMapsproto2(x uint64) (n int) { + return sovMapsproto2(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *FloatingPoint) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FloatingPoint{`, + `F:` + valueToStringMapsproto2(this.F) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllMaps) String() string { + if this == nil { + return "nil" + } + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]*float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]*float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]*int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]*int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]*uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]*uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]*int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]*int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]*uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]*int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]*uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]*int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]*bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]*string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]*MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + s := strings.Join([]string{`&AllMaps{`, + `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`, + `StringToFloatMap:` + mapStringForStringToFloatMap + `,`, + `Int32Map:` + mapStringForInt32Map + `,`, + `Int64Map:` + mapStringForInt64Map + `,`, + `Uint32Map:` + mapStringForUint32Map + `,`, + `Uint64Map:` + mapStringForUint64Map + `,`, + `Sint32Map:` + mapStringForSint32Map + `,`, + `Sint64Map:` + mapStringForSint64Map + `,`, + `Fixed32Map:` + mapStringForFixed32Map + `,`, + `Sfixed32Map:` + mapStringForSfixed32Map + `,`, + `Fixed64Map:` + mapStringForFixed64Map + `,`, + `Sfixed64Map:` + mapStringForSfixed64Map + `,`, + `BoolMap:` + mapStringForBoolMap + `,`, + `StringMap:` + mapStringForStringMap + `,`, + `StringToBytesMap:` + mapStringForStringToBytesMap + `,`, + `StringToEnumMap:` + mapStringForStringToEnumMap + `,`, + `StringToMsgMap:` + mapStringForStringToMsgMap + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringMapsproto2(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *FloatingPoint) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *FloatingPoint) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.F != nil { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = *m.F + i += 8 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AllMaps) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AllMaps) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + keysForStringToDoubleMap := make([]string, 0, len(m.StringToDoubleMap)) + for k := range m.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + for _, k := range keysForStringToDoubleMap { + data[i] = 0xa + i++ + v := m.StringToDoubleMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 8 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x11 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(math.Float64bits(v))) + } + } + if len(m.StringToFloatMap) > 0 { + keysForStringToFloatMap := make([]string, 0, len(m.StringToFloatMap)) + for k := range m.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + for _, k := range keysForStringToFloatMap { + data[i] = 0x12 + i++ + v := m.StringToFloatMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 4 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x15 + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(math.Float32bits(v))) + } + } + if len(m.Int32Map) > 0 { + keysForInt32Map := make([]int32, 0, len(m.Int32Map)) + for k := range m.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + for _, k := range keysForInt32Map { + data[i] = 0x1a + i++ + v := m.Int32Map[k] + mapSize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.Int64Map) > 0 { + keysForInt64Map := make([]int64, 0, len(m.Int64Map)) + for k := range m.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + for _, k := range keysForInt64Map { + data[i] = 0x22 + i++ + v := m.Int64Map[k] + mapSize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.Uint32Map) > 0 { + keysForUint32Map := make([]uint32, 0, len(m.Uint32Map)) + for k := range m.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + for _, k := range keysForUint32Map { + data[i] = 0x2a + i++ + v := m.Uint32Map[k] + mapSize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.Uint64Map) > 0 { + keysForUint64Map := make([]uint64, 0, len(m.Uint64Map)) + for k := range m.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + for _, k := range keysForUint64Map { + data[i] = 0x32 + i++ + v := m.Uint64Map[k] + mapSize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.Sint32Map) > 0 { + keysForSint32Map := make([]int32, 0, len(m.Sint32Map)) + for k := range m.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + for _, k := range keysForSint32Map { + data[i] = 0x3a + i++ + v := m.Sint32Map[k] + mapSize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64((uint32(k)<<1)^uint32((k>>31)))) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64((uint32(v)<<1)^uint32((v>>31)))) + } + } + if len(m.Sint64Map) > 0 { + keysForSint64Map := make([]int64, 0, len(m.Sint64Map)) + for k := range m.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + for _, k := range keysForSint64Map { + data[i] = 0x42 + i++ + v := m.Sint64Map[k] + mapSize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintMapsproto2(data, i, uint64((uint64(k)<<1)^uint64((k>>63)))) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64((uint64(v)<<1)^uint64((v>>63)))) + } + } + if len(m.Fixed32Map) > 0 { + keysForFixed32Map := make([]uint32, 0, len(m.Fixed32Map)) + for k := range m.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + for _, k := range keysForFixed32Map { + data[i] = 0x4a + i++ + v := m.Fixed32Map[k] + mapSize := 1 + 4 + 1 + 4 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xd + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(k)) + data[i] = 0x15 + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(v)) + } + } + if len(m.Sfixed32Map) > 0 { + keysForSfixed32Map := make([]int32, 0, len(m.Sfixed32Map)) + for k := range m.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + for _, k := range keysForSfixed32Map { + data[i] = 0x52 + i++ + v := m.Sfixed32Map[k] + mapSize := 1 + 4 + 1 + 4 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xd + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(k)) + data[i] = 0x15 + i++ + i = encodeFixed32Mapsproto2(data, i, uint32(v)) + } + } + if len(m.Fixed64Map) > 0 { + keysForFixed64Map := make([]uint64, 0, len(m.Fixed64Map)) + for k := range m.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + for _, k := range keysForFixed64Map { + data[i] = 0x5a + i++ + v := m.Fixed64Map[k] + mapSize := 1 + 8 + 1 + 8 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x9 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(k)) + data[i] = 0x11 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(v)) + } + } + if len(m.Sfixed64Map) > 0 { + keysForSfixed64Map := make([]int64, 0, len(m.Sfixed64Map)) + for k := range m.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + for _, k := range keysForSfixed64Map { + data[i] = 0x62 + i++ + v := m.Sfixed64Map[k] + mapSize := 1 + 8 + 1 + 8 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x9 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(k)) + data[i] = 0x11 + i++ + i = encodeFixed64Mapsproto2(data, i, uint64(v)) + } + } + if len(m.BoolMap) > 0 { + keysForBoolMap := make([]bool, 0, len(m.BoolMap)) + for k := range m.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + for _, k := range keysForBoolMap { + data[i] = 0x6a + i++ + v := m.BoolMap[k] + mapSize := 1 + 1 + 1 + 1 + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + if k { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x10 + i++ + if v { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.StringMap) > 0 { + keysForStringMap := make([]string, 0, len(m.StringMap)) + for k := range m.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + for _, k := range keysForStringMap { + data[i] = 0x72 + i++ + v := m.StringMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.StringToBytesMap) > 0 { + keysForStringToBytesMap := make([]string, 0, len(m.StringToBytesMap)) + for k := range m.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + for _, k := range keysForStringToBytesMap { + data[i] = 0x7a + i++ + v := m.StringToBytesMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.StringToEnumMap) > 0 { + keysForStringToEnumMap := make([]string, 0, len(m.StringToEnumMap)) + for k := range m.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + for _, k := range keysForStringToEnumMap { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + v := m.StringToEnumMap[k] + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + sovMapsproto2(uint64(v)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x10 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v)) + } + } + if len(m.StringToMsgMap) > 0 { + keysForStringToMsgMap := make([]string, 0, len(m.StringToMsgMap)) + for k := range m.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + for _, k := range keysForStringToMsgMap { + data[i] = 0x8a + i++ + data[i] = 0x1 + i++ + v := m.StringToMsgMap[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + msgSize + sovMapsproto2(uint64(msgSize)) + i = encodeVarintMapsproto2(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintMapsproto2(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintMapsproto2(data, i, uint64(v.Size())) + n1, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n1 + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Mapsproto2(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Mapsproto2(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintMapsproto2(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafemarshaler/mapsproto2.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafemarshaler/mapsproto2.proto new file mode 100644 index 0000000000000000000000000000000000000000..a7ef7fac0d658ebde1fb8f8b44c93fe11e0cf10c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafemarshaler/mapsproto2.proto @@ -0,0 +1,93 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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"; + +package proto2.maps; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = true; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message FloatingPoint { + optional double f = 1; +} + +enum MapEnum { + MA = 0; + MB = 1; + MC = 2; +} + +message AllMaps { + map StringToDoubleMap = 1; + map StringToFloatMap = 2; + map Int32Map = 3; + map Int64Map = 4; + map Uint32Map = 5; + map Uint64Map = 6; + map Sint32Map = 7; + map Sint64Map = 8; + map Fixed32Map = 9; + map Sfixed32Map = 10; + map Fixed64Map = 11; + map Sfixed64Map = 12; + map BoolMap = 13; + map StringMap = 14; + map StringToBytesMap = 15; + map StringToEnumMap = 16; + map StringToMsgMap = 17; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafemarshaler/mapsproto2pb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafemarshaler/mapsproto2pb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..00aaac5d7b86df119dc906348d9efc11b4cf16e8 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafemarshaler/mapsproto2pb_test.go @@ -0,0 +1,514 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafemarshaler/mapsproto2.proto +// DO NOT EDIT! + +/* +Package proto2_maps is a generated protocol buffer package. + +It is generated from these files: + combos/unsafemarshaler/mapsproto2.proto + +It has these top-level messages: + FloatingPoint + AllMaps +*/ +package proto2_maps + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestFloatingPointProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestFloatingPointMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkFloatingPointProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedFloatingPoint(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &FloatingPoint{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAllMapsMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAllMapsProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMaps(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AllMaps{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllMapsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestFloatingPointProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMapsproto2Description(t *testing.T) { + Mapsproto2Description() +} +func TestFloatingPointVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllMapsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestFloatingPointFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAllMapsFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestFloatingPointGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllMapsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestFloatingPointSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkFloatingPointSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAllMapsSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllMapsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeunmarshaler/mapsproto2.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeunmarshaler/mapsproto2.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..a9c127553f357aacbcf4f5866900c290499b5544 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeunmarshaler/mapsproto2.pb.go @@ -0,0 +1,5391 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeunmarshaler/mapsproto2.proto +// DO NOT EDIT! + +/* + Package proto2_maps is a generated protocol buffer package. + + It is generated from these files: + combos/unsafeunmarshaler/mapsproto2.proto + + It has these top-level messages: + FloatingPoint + AllMaps +*/ +package proto2_maps + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" +import github_com_gogo_protobuf_sortkeys "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/sortkeys" + +import io "io" +import unsafe "unsafe" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type MapEnum int32 + +const ( + MA MapEnum = 0 + MB MapEnum = 1 + MC MapEnum = 2 +) + +var MapEnum_name = map[int32]string{ + 0: "MA", + 1: "MB", + 2: "MC", +} +var MapEnum_value = map[string]int32{ + "MA": 0, + "MB": 1, + "MC": 2, +} + +func (x MapEnum) Enum() *MapEnum { + p := new(MapEnum) + *p = x + return p +} +func (x MapEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(MapEnum_name, int32(x)) +} +func (x *MapEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(MapEnum_value, data, "MapEnum") + if err != nil { + return err + } + *x = MapEnum(value) + return nil +} + +type FloatingPoint struct { + F *float64 `protobuf:"fixed64,1,opt,name=f" json:"f,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FloatingPoint) Reset() { *m = FloatingPoint{} } +func (*FloatingPoint) ProtoMessage() {} + +type AllMaps struct { + StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"` + Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"` + Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"` + Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"` + BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=proto2.maps.MapEnum"` + StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllMaps) Reset() { *m = AllMaps{} } +func (*AllMaps) ProtoMessage() {} + +func init() { + proto.RegisterEnum("proto2.maps.MapEnum", MapEnum_name, MapEnum_value) +} +func (this *FloatingPoint) Description() (desc *google_protobuf.FileDescriptorSet) { + return Mapsproto2Description() +} +func (this *AllMaps) Description() (desc *google_protobuf.FileDescriptorSet) { + return Mapsproto2Description() +} +func Mapsproto2Description() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unsafeunmarshaler/mapsproto2.proto"), + Package: func(v string) *string { return &v }("proto2.maps"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FloatingPoint"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("f"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }, {Name: func(v string) *string { return &v }("AllMaps"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMap"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToDoubleMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToFloatMap"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToFloatMapEntry"), + }, {Name: func(v string) *string { return &v }("Int32Map"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Int32MapEntry"), + }, {Name: func(v string) *string { return &v }("Int64Map"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Int64MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint32Map"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Uint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint64Map"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Uint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint32Map"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint64Map"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed32Map"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Fixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed32Map"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sfixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed64Map"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Fixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed64Map"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.Sfixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("BoolMap"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.BoolMapEntry"), + }, {Name: func(v string) *string { return &v }("StringMap"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToBytesMap"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToBytesMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToEnumMap"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToEnumMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToMsgMap"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.AllMaps.StringToMsgMapEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToFloatMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("BoolMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToBytesMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToEnumMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".proto2.maps.MapEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToMsgMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".proto2.maps.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("MapEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("MA"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("MB"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("MC"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x1})}}, + }}, + } +} +func (x MapEnum) String() string { + s, ok := MapEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *FloatingPoint) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return fmt.Errorf("that is not of type *FloatingPoint") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *FloatingPointbut is not nil && this == nil") + } + if this.F != nil && that1.F != nil { + if *this.F != *that1.F { + return fmt.Errorf("F this(%v) Not Equal that(%v)", *this.F, *that1.F) + } + } else if this.F != nil { + return fmt.Errorf("this.F == nil && that.F != nil") + } else if that1.F != nil { + return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *FloatingPoint) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.F != nil && that1.F != nil { + if *this.F != *that1.F { + return false + } + } else if this.F != nil { + return false + } else if that1.F != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllMaps) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllMaps) + if !ok { + return fmt.Errorf("that is not of type *AllMaps") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllMaps but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllMapsbut is not nil && this == nil") + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap)) + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i]) + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap)) + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i]) + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map)) + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i]) + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map)) + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i]) + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map)) + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i]) + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map)) + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i]) + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map)) + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i]) + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map)) + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i]) + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map)) + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i]) + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map)) + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i]) + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map)) + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i]) + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map)) + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i]) + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap)) + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i]) + } + } + if len(this.StringMap) != len(that1.StringMap) { + return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap)) + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i]) + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap)) + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i]) + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap)) + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i]) + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap)) + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AllMaps) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllMaps) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return false + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return false + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return false + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return false + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return false + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return false + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return false + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return false + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return false + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return false + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return false + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return false + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return false + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return false + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return false + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return false + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return false + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return false + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return false + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return false + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return false + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return false + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return false + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return false + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return false + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return false + } + } + if len(this.StringMap) != len(that1.StringMap) { + return false + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return false + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return false + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return false + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return false + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return false + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return false + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} + +type FloatingPointFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetF() *float64 +} + +func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message { + return NewFloatingPointFromFace(this) +} + +func (this *FloatingPoint) GetF() *float64 { + return this.F +} + +func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint { + this := &FloatingPoint{} + this.F = that.GetF() + return this +} + +type AllMapsFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetStringToDoubleMap() map[string]float64 + GetStringToFloatMap() map[string]float32 + GetInt32Map() map[int32]int32 + GetInt64Map() map[int64]int64 + GetUint32Map() map[uint32]uint32 + GetUint64Map() map[uint64]uint64 + GetSint32Map() map[int32]int32 + GetSint64Map() map[int64]int64 + GetFixed32Map() map[uint32]uint32 + GetSfixed32Map() map[int32]int32 + GetFixed64Map() map[uint64]uint64 + GetSfixed64Map() map[int64]int64 + GetBoolMap() map[bool]bool + GetStringMap() map[string]string + GetStringToBytesMap() map[string][]byte + GetStringToEnumMap() map[string]MapEnum + GetStringToMsgMap() map[string]*FloatingPoint +} + +func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAllMapsFromFace(this) +} + +func (this *AllMaps) GetStringToDoubleMap() map[string]float64 { + return this.StringToDoubleMap +} + +func (this *AllMaps) GetStringToFloatMap() map[string]float32 { + return this.StringToFloatMap +} + +func (this *AllMaps) GetInt32Map() map[int32]int32 { + return this.Int32Map +} + +func (this *AllMaps) GetInt64Map() map[int64]int64 { + return this.Int64Map +} + +func (this *AllMaps) GetUint32Map() map[uint32]uint32 { + return this.Uint32Map +} + +func (this *AllMaps) GetUint64Map() map[uint64]uint64 { + return this.Uint64Map +} + +func (this *AllMaps) GetSint32Map() map[int32]int32 { + return this.Sint32Map +} + +func (this *AllMaps) GetSint64Map() map[int64]int64 { + return this.Sint64Map +} + +func (this *AllMaps) GetFixed32Map() map[uint32]uint32 { + return this.Fixed32Map +} + +func (this *AllMaps) GetSfixed32Map() map[int32]int32 { + return this.Sfixed32Map +} + +func (this *AllMaps) GetFixed64Map() map[uint64]uint64 { + return this.Fixed64Map +} + +func (this *AllMaps) GetSfixed64Map() map[int64]int64 { + return this.Sfixed64Map +} + +func (this *AllMaps) GetBoolMap() map[bool]bool { + return this.BoolMap +} + +func (this *AllMaps) GetStringMap() map[string]string { + return this.StringMap +} + +func (this *AllMaps) GetStringToBytesMap() map[string][]byte { + return this.StringToBytesMap +} + +func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum { + return this.StringToEnumMap +} + +func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint { + return this.StringToMsgMap +} + +func NewAllMapsFromFace(that AllMapsFace) *AllMaps { + this := &AllMaps{} + this.StringToDoubleMap = that.GetStringToDoubleMap() + this.StringToFloatMap = that.GetStringToFloatMap() + this.Int32Map = that.GetInt32Map() + this.Int64Map = that.GetInt64Map() + this.Uint32Map = that.GetUint32Map() + this.Uint64Map = that.GetUint64Map() + this.Sint32Map = that.GetSint32Map() + this.Sint64Map = that.GetSint64Map() + this.Fixed32Map = that.GetFixed32Map() + this.Sfixed32Map = that.GetSfixed32Map() + this.Fixed64Map = that.GetFixed64Map() + this.Sfixed64Map = that.GetSfixed64Map() + this.BoolMap = that.GetBoolMap() + this.StringMap = that.GetStringMap() + this.StringToBytesMap = that.GetStringToBytesMap() + this.StringToEnumMap = that.GetStringToEnumMap() + this.StringToMsgMap = that.GetStringToMsgMap() + return this +} + +func (this *FloatingPoint) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&proto2_maps.FloatingPoint{") + if this.F != nil { + s = append(s, "F: "+valueToGoStringMapsproto2(this.F, "float64")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllMaps) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 21) + s = append(s, "&proto2_maps.AllMaps{") + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + if this.StringToDoubleMap != nil { + s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n") + } + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + if this.StringToFloatMap != nil { + s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n") + } + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + if this.Int32Map != nil { + s = append(s, "Int32Map: "+mapStringForInt32Map+",\n") + } + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + if this.Int64Map != nil { + s = append(s, "Int64Map: "+mapStringForInt64Map+",\n") + } + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + if this.Uint32Map != nil { + s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n") + } + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + if this.Uint64Map != nil { + s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n") + } + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + if this.Sint32Map != nil { + s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n") + } + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + if this.Sint64Map != nil { + s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n") + } + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + if this.Fixed32Map != nil { + s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n") + } + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + if this.Sfixed32Map != nil { + s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n") + } + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + if this.Fixed64Map != nil { + s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n") + } + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + if this.Sfixed64Map != nil { + s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n") + } + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + if this.BoolMap != nil { + s = append(s, "BoolMap: "+mapStringForBoolMap+",\n") + } + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + if this.StringMap != nil { + s = append(s, "StringMap: "+mapStringForStringMap+",\n") + } + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + if this.StringToBytesMap != nil { + s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n") + } + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + if this.StringToEnumMap != nil { + s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n") + } + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + if this.StringToMsgMap != nil { + s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringMapsproto2(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringMapsproto2(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedFloatingPoint(r randyMapsproto2, easy bool) *FloatingPoint { + this := &FloatingPoint{} + if r.Intn(10) != 0 { + v1 := float64(r.Float64()) + if r.Intn(2) == 0 { + v1 *= -1 + } + this.F = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 2) + } + return this +} + +func NewPopulatedAllMaps(r randyMapsproto2, easy bool) *AllMaps { + this := &AllMaps{} + if r.Intn(10) != 0 { + v2 := r.Intn(10) + this.StringToDoubleMap = make(map[string]float64) + for i := 0; i < v2; i++ { + v3 := randStringMapsproto2(r) + this.StringToDoubleMap[v3] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.StringToDoubleMap[v3] *= -1 + } + } + } + if r.Intn(10) != 0 { + v4 := r.Intn(10) + this.StringToFloatMap = make(map[string]float32) + for i := 0; i < v4; i++ { + v5 := randStringMapsproto2(r) + this.StringToFloatMap[v5] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.StringToFloatMap[v5] *= -1 + } + } + } + if r.Intn(10) != 0 { + v6 := r.Intn(10) + this.Int32Map = make(map[int32]int32) + for i := 0; i < v6; i++ { + v7 := int32(r.Int31()) + this.Int32Map[v7] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Int32Map[v7] *= -1 + } + } + } + if r.Intn(10) != 0 { + v8 := r.Intn(10) + this.Int64Map = make(map[int64]int64) + for i := 0; i < v8; i++ { + v9 := int64(r.Int63()) + this.Int64Map[v9] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Int64Map[v9] *= -1 + } + } + } + if r.Intn(10) != 0 { + v10 := r.Intn(10) + this.Uint32Map = make(map[uint32]uint32) + for i := 0; i < v10; i++ { + v11 := uint32(r.Uint32()) + this.Uint32Map[v11] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v12 := r.Intn(10) + this.Uint64Map = make(map[uint64]uint64) + for i := 0; i < v12; i++ { + v13 := uint64(uint64(r.Uint32())) + this.Uint64Map[v13] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v14 := r.Intn(10) + this.Sint32Map = make(map[int32]int32) + for i := 0; i < v14; i++ { + v15 := int32(r.Int31()) + this.Sint32Map[v15] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sint32Map[v15] *= -1 + } + } + } + if r.Intn(10) != 0 { + v16 := r.Intn(10) + this.Sint64Map = make(map[int64]int64) + for i := 0; i < v16; i++ { + v17 := int64(r.Int63()) + this.Sint64Map[v17] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sint64Map[v17] *= -1 + } + } + } + if r.Intn(10) != 0 { + v18 := r.Intn(10) + this.Fixed32Map = make(map[uint32]uint32) + for i := 0; i < v18; i++ { + v19 := uint32(r.Uint32()) + this.Fixed32Map[v19] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v20 := r.Intn(10) + this.Sfixed32Map = make(map[int32]int32) + for i := 0; i < v20; i++ { + v21 := int32(r.Int31()) + this.Sfixed32Map[v21] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sfixed32Map[v21] *= -1 + } + } + } + if r.Intn(10) != 0 { + v22 := r.Intn(10) + this.Fixed64Map = make(map[uint64]uint64) + for i := 0; i < v22; i++ { + v23 := uint64(uint64(r.Uint32())) + this.Fixed64Map[v23] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v24 := r.Intn(10) + this.Sfixed64Map = make(map[int64]int64) + for i := 0; i < v24; i++ { + v25 := int64(r.Int63()) + this.Sfixed64Map[v25] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sfixed64Map[v25] *= -1 + } + } + } + if r.Intn(10) != 0 { + v26 := r.Intn(10) + this.BoolMap = make(map[bool]bool) + for i := 0; i < v26; i++ { + v27 := bool(bool(r.Intn(2) == 0)) + this.BoolMap[v27] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v28 := r.Intn(10) + this.StringMap = make(map[string]string) + for i := 0; i < v28; i++ { + this.StringMap[randStringMapsproto2(r)] = randStringMapsproto2(r) + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(10) + this.StringToBytesMap = make(map[string][]byte) + for i := 0; i < v29; i++ { + v30 := r.Intn(100) + v31 := randStringMapsproto2(r) + this.StringToBytesMap[v31] = make([]byte, v30) + for i := 0; i < v30; i++ { + this.StringToBytesMap[v31][i] = byte(r.Intn(256)) + } + } + } + if r.Intn(10) != 0 { + v32 := r.Intn(10) + this.StringToEnumMap = make(map[string]MapEnum) + for i := 0; i < v32; i++ { + this.StringToEnumMap[randStringMapsproto2(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if r.Intn(10) != 0 { + v33 := r.Intn(10) + this.StringToMsgMap = make(map[string]*FloatingPoint) + for i := 0; i < v33; i++ { + this.StringToMsgMap[randStringMapsproto2(r)] = NewPopulatedFloatingPoint(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedMapsproto2(r, 18) + } + return this +} + +type randyMapsproto2 interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneMapsproto2(r randyMapsproto2) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringMapsproto2(r randyMapsproto2) string { + v34 := r.Intn(100) + tmps := make([]rune, v34) + for i := 0; i < v34; i++ { + tmps[i] = randUTF8RuneMapsproto2(r) + } + return string(tmps) +} +func randUnrecognizedMapsproto2(r randyMapsproto2, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldMapsproto2(data, r, fieldNumber, wire) + } + return data +} +func randFieldMapsproto2(data []byte, r randyMapsproto2, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + v35 := r.Int63() + if r.Intn(2) == 0 { + v35 *= -1 + } + data = encodeVarintPopulateMapsproto2(data, uint64(v35)) + case 1: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateMapsproto2(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateMapsproto2(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateMapsproto2(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *FloatingPoint) Size() (n int) { + var l int + _ = l + if m.F != nil { + n += 9 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllMaps) Size() (n int) { + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + for k, v := range m.StringToDoubleMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToFloatMap) > 0 { + for k, v := range m.StringToFloatMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Int32Map) > 0 { + for k, v := range m.Int32Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Int64Map) > 0 { + for k, v := range m.Int64Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Uint32Map) > 0 { + for k, v := range m.Uint32Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Uint64Map) > 0 { + for k, v := range m.Uint64Map { + _ = k + _ = v + mapEntrySize := 1 + sovMapsproto2(uint64(k)) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sint32Map) > 0 { + for k, v := range m.Sint32Map { + _ = k + _ = v + mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sint64Map) > 0 { + for k, v := range m.Sint64Map { + _ = k + _ = v + mapEntrySize := 1 + sozMapsproto2(uint64(k)) + 1 + sozMapsproto2(uint64(v)) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Fixed32Map) > 0 { + for k, v := range m.Fixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sfixed32Map) > 0 { + for k, v := range m.Sfixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Fixed64Map) > 0 { + for k, v := range m.Fixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.Sfixed64Map) > 0 { + for k, v := range m.Sfixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.BoolMap) > 0 { + for k, v := range m.BoolMap { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + 1 + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringMap) > 0 { + for k, v := range m.StringMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToBytesMap) > 0 { + for k, v := range m.StringToBytesMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + len(v) + sovMapsproto2(uint64(len(v))) + n += mapEntrySize + 1 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToEnumMap) > 0 { + for k, v := range m.StringToEnumMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + sovMapsproto2(uint64(v)) + n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if len(m.StringToMsgMap) > 0 { + for k, v := range m.StringToMsgMap { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + len(k) + sovMapsproto2(uint64(len(k))) + 1 + l + sovMapsproto2(uint64(l)) + n += mapEntrySize + 2 + sovMapsproto2(uint64(mapEntrySize)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovMapsproto2(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozMapsproto2(x uint64) (n int) { + return sovMapsproto2(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *FloatingPoint) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FloatingPoint{`, + `F:` + valueToStringMapsproto2(this.F) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllMaps) String() string { + if this == nil { + return "nil" + } + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]*float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]*float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]*int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]*int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]*uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]*uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]*int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]*int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]*uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]*int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]*uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]*int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]*bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]*string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]*MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + s := strings.Join([]string{`&AllMaps{`, + `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`, + `StringToFloatMap:` + mapStringForStringToFloatMap + `,`, + `Int32Map:` + mapStringForInt32Map + `,`, + `Int64Map:` + mapStringForInt64Map + `,`, + `Uint32Map:` + mapStringForUint32Map + `,`, + `Uint64Map:` + mapStringForUint64Map + `,`, + `Sint32Map:` + mapStringForSint32Map + `,`, + `Sint64Map:` + mapStringForSint64Map + `,`, + `Fixed32Map:` + mapStringForFixed32Map + `,`, + `Sfixed32Map:` + mapStringForSfixed32Map + `,`, + `Fixed64Map:` + mapStringForFixed64Map + `,`, + `Sfixed64Map:` + mapStringForSfixed64Map + `,`, + `BoolMap:` + mapStringForBoolMap + `,`, + `StringMap:` + mapStringForStringMap + `,`, + `StringToBytesMap:` + mapStringForStringToBytesMap + `,`, + `StringToEnumMap:` + mapStringForStringToEnumMap + `,`, + `StringToMsgMap:` + mapStringForStringToMsgMap + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringMapsproto2(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *FloatingPoint) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FloatingPoint: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FloatingPoint: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field F", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.F = &v + default: + iNdEx = preIndex + skippy, err := skipMapsproto2Unsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AllMaps) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AllMaps: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AllMaps: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvaluetemp = uint64(data[iNdEx-8]) + mapvaluetemp |= uint64(data[iNdEx-7]) << 8 + mapvaluetemp |= uint64(data[iNdEx-6]) << 16 + mapvaluetemp |= uint64(data[iNdEx-5]) << 24 + mapvaluetemp |= uint64(data[iNdEx-4]) << 32 + mapvaluetemp |= uint64(data[iNdEx-3]) << 40 + mapvaluetemp |= uint64(data[iNdEx-2]) << 48 + mapvaluetemp |= uint64(data[iNdEx-1]) << 56 + mapvalue := math.Float64frombits(mapvaluetemp) + if m.StringToDoubleMap == nil { + m.StringToDoubleMap = make(map[string]float64) + } + m.StringToDoubleMap[mapkey] = mapvalue + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvaluetemp = uint32(data[iNdEx-4]) + mapvaluetemp |= uint32(data[iNdEx-3]) << 8 + mapvaluetemp |= uint32(data[iNdEx-2]) << 16 + mapvaluetemp |= uint32(data[iNdEx-1]) << 24 + mapvalue := math.Float32frombits(mapvaluetemp) + if m.StringToFloatMap == nil { + m.StringToFloatMap = make(map[string]float32) + } + m.StringToFloatMap[mapkey] = mapvalue + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Int32Map == nil { + m.Int32Map = make(map[int32]int32) + } + m.Int32Map[mapkey] = mapvalue + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Int64Map == nil { + m.Int64Map = make(map[int64]int64) + } + m.Int64Map[mapkey] = mapvalue + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Uint32Map == nil { + m.Uint32Map = make(map[uint32]uint32) + } + m.Uint32Map[mapkey] = mapvalue + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Uint64Map == nil { + m.Uint64Map = make(map[uint64]uint64) + } + m.Uint64Map[mapkey] = mapvalue + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31)) + mapkey := int32(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31)) + mapvalue := int32(mapvaluetemp) + if m.Sint32Map == nil { + m.Sint32Map = make(map[int32]int32) + } + m.Sint32Map[mapkey] = mapvalue + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63) + mapkey := int64(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63) + mapvalue := int64(mapvaluetemp) + if m.Sint64Map == nil { + m.Sint64Map = make(map[int64]int64) + } + m.Sint64Map[mapkey] = mapvalue + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapkey = uint32(data[iNdEx-4]) + mapkey |= uint32(data[iNdEx-3]) << 8 + mapkey |= uint32(data[iNdEx-2]) << 16 + mapkey |= uint32(data[iNdEx-1]) << 24 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvalue = uint32(data[iNdEx-4]) + mapvalue |= uint32(data[iNdEx-3]) << 8 + mapvalue |= uint32(data[iNdEx-2]) << 16 + mapvalue |= uint32(data[iNdEx-1]) << 24 + if m.Fixed32Map == nil { + m.Fixed32Map = make(map[uint32]uint32) + } + m.Fixed32Map[mapkey] = mapvalue + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapkey = int32(data[iNdEx-4]) + mapkey |= int32(data[iNdEx-3]) << 8 + mapkey |= int32(data[iNdEx-2]) << 16 + mapkey |= int32(data[iNdEx-1]) << 24 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvalue = int32(data[iNdEx-4]) + mapvalue |= int32(data[iNdEx-3]) << 8 + mapvalue |= int32(data[iNdEx-2]) << 16 + mapvalue |= int32(data[iNdEx-1]) << 24 + if m.Sfixed32Map == nil { + m.Sfixed32Map = make(map[int32]int32) + } + m.Sfixed32Map[mapkey] = mapvalue + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapkey = uint64(data[iNdEx-8]) + mapkey |= uint64(data[iNdEx-7]) << 8 + mapkey |= uint64(data[iNdEx-6]) << 16 + mapkey |= uint64(data[iNdEx-5]) << 24 + mapkey |= uint64(data[iNdEx-4]) << 32 + mapkey |= uint64(data[iNdEx-3]) << 40 + mapkey |= uint64(data[iNdEx-2]) << 48 + mapkey |= uint64(data[iNdEx-1]) << 56 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvalue = uint64(data[iNdEx-8]) + mapvalue |= uint64(data[iNdEx-7]) << 8 + mapvalue |= uint64(data[iNdEx-6]) << 16 + mapvalue |= uint64(data[iNdEx-5]) << 24 + mapvalue |= uint64(data[iNdEx-4]) << 32 + mapvalue |= uint64(data[iNdEx-3]) << 40 + mapvalue |= uint64(data[iNdEx-2]) << 48 + mapvalue |= uint64(data[iNdEx-1]) << 56 + if m.Fixed64Map == nil { + m.Fixed64Map = make(map[uint64]uint64) + } + m.Fixed64Map[mapkey] = mapvalue + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapkey = int64(data[iNdEx-8]) + mapkey |= int64(data[iNdEx-7]) << 8 + mapkey |= int64(data[iNdEx-6]) << 16 + mapkey |= int64(data[iNdEx-5]) << 24 + mapkey |= int64(data[iNdEx-4]) << 32 + mapkey |= int64(data[iNdEx-3]) << 40 + mapkey |= int64(data[iNdEx-2]) << 48 + mapkey |= int64(data[iNdEx-1]) << 56 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvalue = int64(data[iNdEx-8]) + mapvalue |= int64(data[iNdEx-7]) << 8 + mapvalue |= int64(data[iNdEx-6]) << 16 + mapvalue |= int64(data[iNdEx-5]) << 24 + mapvalue |= int64(data[iNdEx-4]) << 32 + mapvalue |= int64(data[iNdEx-3]) << 40 + mapvalue |= int64(data[iNdEx-2]) << 48 + mapvalue |= int64(data[iNdEx-1]) << 56 + if m.Sfixed64Map == nil { + m.Sfixed64Map = make(map[int64]int64) + } + m.Sfixed64Map[mapkey] = mapvalue + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkey := bool(mapkeytemp != 0) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvalue := bool(mapvaluetemp != 0) + if m.BoolMap == nil { + m.BoolMap = make(map[bool]bool) + } + m.BoolMap[mapkey] = mapvalue + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue := string(data[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + if m.StringMap == nil { + m.StringMap = make(map[string]string) + } + m.StringMap[mapkey] = mapvalue + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapbyteLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := make([]byte, mapbyteLen) + copy(mapvalue, data[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + if m.StringToBytesMap == nil { + m.StringToBytesMap = make(map[string][]byte) + } + m.StringToBytesMap[mapkey] = mapvalue + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue MapEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (MapEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.StringToEnumMap == nil { + m.StringToEnumMap = make(map[string]MapEnum) + } + m.StringToEnumMap[mapkey] = mapvalue + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &FloatingPoint{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.StringToMsgMap == nil { + m.StringToMsgMap = make(map[string]*FloatingPoint) + } + m.StringToMsgMap[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipMapsproto2Unsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthMapsproto2Unsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipMapsproto2Unsafe(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthMapsproto2Unsafe + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMapsproto2Unsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipMapsproto2Unsafe(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthMapsproto2Unsafe = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowMapsproto2Unsafe = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeunmarshaler/mapsproto2.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeunmarshaler/mapsproto2.proto new file mode 100644 index 0000000000000000000000000000000000000000..2a99f0e1eb1c3ddaa73be355ada95aabb02e4ab2 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeunmarshaler/mapsproto2.proto @@ -0,0 +1,93 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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"; + +package proto2.maps; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = true; + +message FloatingPoint { + optional double f = 1; +} + +enum MapEnum { + MA = 0; + MB = 1; + MC = 2; +} + +message AllMaps { + map StringToDoubleMap = 1; + map StringToFloatMap = 2; + map Int32Map = 3; + map Int64Map = 4; + map Uint32Map = 5; + map Uint64Map = 6; + map Sint32Map = 7; + map Sint64Map = 8; + map Fixed32Map = 9; + map Sfixed32Map = 10; + map Fixed64Map = 11; + map Sfixed64Map = 12; + map BoolMap = 13; + map StringMap = 14; + map StringToBytesMap = 15; + map StringToEnumMap = 16; + map StringToMsgMap = 17; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeunmarshaler/mapsproto2pb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeunmarshaler/mapsproto2pb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..d5ed8b0f0f0e8f0cf4db25c81f6c6ef70424c3e4 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/combos/unsafeunmarshaler/mapsproto2pb_test.go @@ -0,0 +1,458 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeunmarshaler/mapsproto2.proto +// DO NOT EDIT! + +/* +Package proto2_maps is a generated protocol buffer package. + +It is generated from these files: + combos/unsafeunmarshaler/mapsproto2.proto + +It has these top-level messages: + FloatingPoint + AllMaps +*/ +package proto2_maps + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestFloatingPointProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkFloatingPointProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedFloatingPoint(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &FloatingPoint{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAllMapsProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMaps(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AllMaps{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllMapsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestFloatingPointProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMapsproto2Description(t *testing.T) { + Mapsproto2Description() +} +func TestFloatingPointVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllMapsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestFloatingPointFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAllMapsFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestFloatingPointGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllMapsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestFloatingPointSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkFloatingPointSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAllMapsSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllMapsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/doc.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/doc.go new file mode 100644 index 0000000000000000000000000000000000000000..4276bac39fc6d28e0e72f57d7e0d34f432c7dbd6 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/doc.go @@ -0,0 +1 @@ +package mapsproto2 diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/header.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/header.proto new file mode 100644 index 0000000000000000000000000000000000000000..dbdc990e092608f1aad378209e598e5237b490db --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/header.proto @@ -0,0 +1,67 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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"; + +package proto2.maps; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message FloatingPoint { + optional double f = 1; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/mapsproto2.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/mapsproto2.proto new file mode 100644 index 0000000000000000000000000000000000000000..3de81b0c5390d6f74549a30a7e76df1d228d569b --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mapsproto2/mapsproto2.proto @@ -0,0 +1,93 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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"; + +package proto2.maps; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message FloatingPoint { + optional double f = 1; +} + +enum MapEnum { + MA = 0; + MB = 1; + MC = 2; +} + +message AllMaps { + map StringToDoubleMap = 1; + map StringToFloatMap = 2; + map Int32Map = 3; + map Int64Map = 4; + map Uint32Map = 5; + map Uint64Map = 6; + map Sint32Map = 7; + map Sint64Map = 8; + map Fixed32Map = 9; + map Sfixed32Map = 10; + map Fixed64Map = 11; + map Sfixed64Map = 12; + map BoolMap = 13; + map StringMap = 14; + map StringToBytesMap = 15; + map StringToEnumMap = 16; + map StringToMsgMap = 17; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/marshal.txt b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/marshal.txt new file mode 100644 index 0000000000000000000000000000000000000000..b35291ce9a71e6767750eddacf56434b204e2c5d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/marshal.txt @@ -0,0 +1,49 @@ +PASS +BenchmarkNidOptNativeProtoMarshal-4 1000000 1912 ns/op 194.48 MB/s +BenchmarkNinOptNativeProtoMarshal-4 1000000 2207 ns/op 154.04 MB/s +BenchmarkNidRepNativeProtoMarshal-4 50000 36321 ns/op 195.12 MB/s +BenchmarkNinRepNativeProtoMarshal-4 50000 36979 ns/op 191.65 MB/s +BenchmarkNidRepPackedNativeProtoMarshal-4 50000 29607 ns/op 115.41 MB/s +BenchmarkNinRepPackedNativeProtoMarshal-4 50000 29781 ns/op 114.73 MB/s +BenchmarkNidOptStructProtoMarshal-4 500000 6986 ns/op 201.40 MB/s +BenchmarkNinOptStructProtoMarshal-4 500000 7044 ns/op 180.14 MB/s +BenchmarkNidRepStructProtoMarshal-4 50000 40141 ns/op 219.87 MB/s +BenchmarkNinRepStructProtoMarshal-4 50000 40930 ns/op 215.63 MB/s +BenchmarkNidEmbeddedStructProtoMarshal-4 500000 4595 ns/op 163.62 MB/s +BenchmarkNinEmbeddedStructProtoMarshal-4 500000 4502 ns/op 158.37 MB/s +BenchmarkNidNestedStructProtoMarshal-4 10000 171850 ns/op 215.28 MB/s +BenchmarkNinNestedStructProtoMarshal-4 10000 150174 ns/op 246.19 MB/s +BenchmarkNidOptCustomProtoMarshal-4 1000000 1867 ns/op 38.02 MB/s +BenchmarkNinOptCustomProtoMarshal-4 1000000 1799 ns/op 37.24 MB/s +BenchmarkNidRepCustomProtoMarshal-4 500000 4120 ns/op 43.93 MB/s +BenchmarkNinRepCustomProtoMarshal-4 500000 4059 ns/op 44.58 MB/s +BenchmarkNinOptNativeUnionProtoMarshal-4 1000000 1316 ns/op 23.54 MB/s +BenchmarkNinOptStructUnionProtoMarshal-4 1000000 1945 ns/op 57.06 MB/s +BenchmarkNinEmbeddedStructUnionProtoMarshal-4 1000000 2861 ns/op 84.22 MB/s +BenchmarkNinNestedStructUnionProtoMarshal-4 1000000 2490 ns/op 52.60 MB/s +BenchmarkTreeProtoMarshal-4 1000000 2293 ns/op 109.89 MB/s +BenchmarkOrBranchProtoMarshal-4 500000 4401 ns/op 124.74 MB/s +BenchmarkAndBranchProtoMarshal-4 500000 4394 ns/op 124.93 MB/s +BenchmarkLeafProtoMarshal-4 1000000 1696 ns/op 142.68 MB/s +BenchmarkDeepTreeProtoMarshal-4 500000 3740 ns/op 79.40 MB/s +BenchmarkADeepBranchProtoMarshal-4 500000 4677 ns/op 71.41 MB/s +BenchmarkAndDeepBranchProtoMarshal-4 500000 6597 ns/op 96.25 MB/s +BenchmarkDeepLeafProtoMarshal-4 500000 3179 ns/op 91.21 MB/s +BenchmarkNilProtoMarshal-4 1000000 1326 ns/op 26.39 MB/s +BenchmarkNidOptEnumProtoMarshal-4 1000000 1360 ns/op 27.20 MB/s +BenchmarkNinOptEnumProtoMarshal-4 1000000 1360 ns/op 26.46 MB/s +BenchmarkNidRepEnumProtoMarshal-4 1000000 1314 ns/op 32.72 MB/s +BenchmarkNinRepEnumProtoMarshal-4 1000000 1311 ns/op 32.78 MB/s +BenchmarkNinOptEnumDefaultProtoMarshal-4 1000000 1349 ns/op 26.67 MB/s +BenchmarkAnotherNinOptEnumProtoMarshal-4 1000000 1369 ns/op 26.29 MB/s +BenchmarkAnotherNinOptEnumDefaultProtoMarshal-4 1000000 1341 ns/op 26.84 MB/s +BenchmarkTimerProtoMarshal-4 1000000 1604 ns/op 65.45 MB/s +BenchmarkMyExtendableProtoMarshal-4 1000000 1545 ns/op 51.75 MB/s +BenchmarkOtherExtenableProtoMarshal-4 1000000 2704 ns/op 58.04 MB/s +BenchmarkNestedDefinitionProtoMarshal-4 500000 4177 ns/op 108.92 MB/s +BenchmarkNestedDefinition_NestedMessageProtoMarshal-4 1000000 2473 ns/op 95.43 MB/s +BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoMarshal-4 1000000 1616 ns/op 131.14 MB/s +BenchmarkNestedScopeProtoMarshal-4 500000 4058 ns/op 110.14 MB/s +BenchmarkNinOptNativeDefaultProtoMarshal-4 500000 2863 ns/op 118.72 MB/s +BenchmarkCustomContainerProtoMarshal-4 1000000 2289 ns/op 47.17 MB/s +ok github.com/gogo/protobuf/test/mixbench/testdata 152.674s diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/marshaler.txt b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/marshaler.txt new file mode 100644 index 0000000000000000000000000000000000000000..08a35975d4b83480da470990c08f8cdd88a637a2 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/marshaler.txt @@ -0,0 +1,49 @@ +PASS +BenchmarkNidOptNativeProtoMarshal-4 5000000 558 ns/op 665.90 MB/s +BenchmarkNinOptNativeProtoMarshal-4 5000000 632 ns/op 537.89 MB/s +BenchmarkNidRepNativeProtoMarshal-4 200000 9070 ns/op 781.29 MB/s +BenchmarkNinRepNativeProtoMarshal-4 200000 8943 ns/op 792.42 MB/s +BenchmarkNidRepPackedNativeProtoMarshal-4 200000 8142 ns/op 419.65 MB/s +BenchmarkNinRepPackedNativeProtoMarshal-4 200000 8114 ns/op 421.11 MB/s +BenchmarkNidOptStructProtoMarshal-4 1000000 2018 ns/op 697.03 MB/s +BenchmarkNinOptStructProtoMarshal-4 1000000 1919 ns/op 661.19 MB/s +BenchmarkNidRepStructProtoMarshal-4 100000 11442 ns/op 771.31 MB/s +BenchmarkNinRepStructProtoMarshal-4 200000 10742 ns/op 821.60 MB/s +BenchmarkNidEmbeddedStructProtoMarshal-4 1000000 1203 ns/op 624.73 MB/s +BenchmarkNinEmbeddedStructProtoMarshal-4 1000000 1135 ns/op 627.68 MB/s +BenchmarkNidNestedStructProtoMarshal-4 50000 56182 ns/op 658.50 MB/s +BenchmarkNinNestedStructProtoMarshal-4 50000 49802 ns/op 742.37 MB/s +BenchmarkNidOptCustomProtoMarshal-4 5000000 303 ns/op 233.89 MB/s +BenchmarkNinOptCustomProtoMarshal-4 10000000 280 ns/op 238.94 MB/s +BenchmarkNidRepCustomProtoMarshal-4 5000000 604 ns/op 299.21 MB/s +BenchmarkNinRepCustomProtoMarshal-4 5000000 599 ns/op 301.77 MB/s +BenchmarkNinOptNativeUnionProtoMarshal-4 10000000 196 ns/op 158.04 MB/s +BenchmarkNinOptStructUnionProtoMarshal-4 5000000 384 ns/op 288.81 MB/s +BenchmarkNinEmbeddedStructUnionProtoMarshal-4 5000000 662 ns/op 363.93 MB/s +BenchmarkNinNestedStructUnionProtoMarshal-4 5000000 502 ns/op 260.48 MB/s +BenchmarkTreeProtoMarshal-4 5000000 558 ns/op 451.53 MB/s +BenchmarkOrBranchProtoMarshal-4 2000000 992 ns/op 553.08 MB/s +BenchmarkAndBranchProtoMarshal-4 2000000 998 ns/op 550.04 MB/s +BenchmarkLeafProtoMarshal-4 5000000 523 ns/op 462.20 MB/s +BenchmarkDeepTreeProtoMarshal-4 5000000 691 ns/op 429.41 MB/s +BenchmarkADeepBranchProtoMarshal-4 2000000 787 ns/op 424.31 MB/s +BenchmarkAndDeepBranchProtoMarshal-4 1000000 1329 ns/op 477.67 MB/s +BenchmarkDeepLeafProtoMarshal-4 5000000 639 ns/op 453.35 MB/s +BenchmarkNilProtoMarshal-4 10000000 189 ns/op 184.92 MB/s +BenchmarkNidOptEnumProtoMarshal-4 10000000 216 ns/op 170.86 MB/s +BenchmarkNinOptEnumProtoMarshal-4 10000000 209 ns/op 171.60 MB/s +BenchmarkNidRepEnumProtoMarshal-4 10000000 237 ns/op 180.80 MB/s +BenchmarkNinRepEnumProtoMarshal-4 10000000 235 ns/op 182.93 MB/s +BenchmarkNinOptEnumDefaultProtoMarshal-4 10000000 209 ns/op 171.51 MB/s +BenchmarkAnotherNinOptEnumProtoMarshal-4 10000000 211 ns/op 170.44 MB/s +BenchmarkAnotherNinOptEnumDefaultProtoMarshal-4 10000000 214 ns/op 167.95 MB/s +BenchmarkTimerProtoMarshal-4 5000000 344 ns/op 305.21 MB/s +BenchmarkMyExtendableProtoMarshal-4 5000000 695 ns/op 115.09 MB/s +BenchmarkOtherExtenableProtoMarshal-4 1000000 1295 ns/op 121.15 MB/s +BenchmarkNestedDefinitionProtoMarshal-4 2000000 906 ns/op 501.69 MB/s +BenchmarkNestedDefinition_NestedMessageProtoMarshal-4 5000000 537 ns/op 438.85 MB/s +BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoMarshal-4 5000000 479 ns/op 442.52 MB/s +BenchmarkNestedScopeProtoMarshal-4 2000000 862 ns/op 518.19 MB/s +BenchmarkNinOptNativeDefaultProtoMarshal-4 2000000 758 ns/op 448.10 MB/s +BenchmarkCustomContainerProtoMarshal-4 5000000 390 ns/op 276.58 MB/s +ok github.com/gogo/protobuf/test/mixbench/testdata 190.796s diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/mixbench.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/mixbench.go new file mode 100644 index 0000000000000000000000000000000000000000..32aed64230395465a861e9af23728c8111b4a837 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/mixbench.go @@ -0,0 +1,136 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 main + +import ( + "fmt" + "io/ioutil" + "os" + "os/exec" + "strings" +) + +type MixMatch struct { + Old []string + New []string +} + +func (this *MixMatch) Regenerate() { + fmt.Printf("mixbench\n") + uuidData, err := ioutil.ReadFile("../uuid.go") + if err != nil { + panic(err) + } + if err := ioutil.WriteFile("./testdata/uuid.go", uuidData, 0666); err != nil { + panic(err) + } + data, err := ioutil.ReadFile("../thetest.proto") + if err != nil { + panic(err) + } + content := string(data) + for i, old := range this.Old { + content = strings.Replace(content, old, this.New[i], -1) + } + if err := ioutil.WriteFile("./testdata/thetest.proto", []byte(content), 0666); err != nil { + panic(err) + } + var regenerate = exec.Command("protoc", "--gogo_out=.", "-I=../../:../../protobuf/:../../../../../:.", "./testdata/thetest.proto") + fmt.Printf("regenerating\n") + out, err := regenerate.CombinedOutput() + fmt.Printf("regenerate output: %v\n", string(out)) + if err != nil { + panic(err) + } +} + +func (this *MixMatch) Bench(rgx string, outFileName string) { + if err := os.MkdirAll("./testdata", 0777); err != nil { + panic(err) + } + this.Regenerate() + var test = exec.Command("go", "test", "-test.timeout=20m", "-test.v", "-test.run=XXX", "-test.bench="+rgx, "./testdata/") + fmt.Printf("benching\n") + out, err := test.CombinedOutput() + fmt.Printf("bench output: %v\n", string(out)) + if err != nil { + panic(err) + } + if err := ioutil.WriteFile(outFileName, out, 0666); err != nil { + panic(err) + } + if err := os.RemoveAll("./testdata"); err != nil { + panic(err) + } +} + +func NewMixMatch(marshaler, unmarshaler, unsafe_marshaler, unsafe_unmarshaler bool) *MixMatch { + mm := &MixMatch{} + if marshaler { + mm.Old = append(mm.Old, "option (gogoproto.marshaler_all) = false;") + mm.New = append(mm.New, "option (gogoproto.marshaler_all) = true;") + } else { + mm.Old = append(mm.Old, "option (gogoproto.marshaler_all) = true;") + mm.New = append(mm.New, "option (gogoproto.marshaler_all) = false;") + } + if unmarshaler { + mm.Old = append(mm.Old, "option (gogoproto.unmarshaler_all) = false;") + mm.New = append(mm.New, "option (gogoproto.unmarshaler_all) = true;") + } else { + mm.Old = append(mm.Old, "option (gogoproto.unmarshaler_all) = true;") + mm.New = append(mm.New, "option (gogoproto.unmarshaler_all) = false;") + } + if unsafe_marshaler { + mm.Old = append(mm.Old, "option (gogoproto.unsafe_marshaler_all) = false;") + mm.New = append(mm.New, "option (gogoproto.unsafe_marshaler_all) = true;") + } else { + mm.Old = append(mm.Old, "option (gogoproto.unsafe_marshaler_all) = true;") + mm.New = append(mm.New, "option (gogoproto.unsafe_marshaler_all) = false;") + } + if unsafe_unmarshaler { + mm.Old = append(mm.Old, "option (gogoproto.unsafe_unmarshaler_all) = false;") + mm.New = append(mm.New, "option (gogoproto.unsafe_unmarshaler_all) = true;") + } else { + mm.Old = append(mm.Old, "option (gogoproto.unsafe_unmarshaler_all) = true;") + mm.New = append(mm.New, "option (gogoproto.unsafe_unmarshaler_all) = false;") + } + return mm +} + +func main() { + NewMixMatch(true, true, false, false).Bench("ProtoMarshal", "marshaler.txt") + NewMixMatch(false, false, false, false).Bench("ProtoMarshal", "marshal.txt") + NewMixMatch(false, false, true, true).Bench("ProtoMarshal", "unsafe_marshaler.txt") + NewMixMatch(true, true, false, false).Bench("ProtoUnmarshal", "unmarshaler.txt") + NewMixMatch(false, false, false, false).Bench("ProtoUnmarshal", "unmarshal.txt") + NewMixMatch(false, false, true, true).Bench("ProtoUnmarshal", "unsafe_unmarshaler.txt") + fmt.Println("Running benchcmp will show the performance difference between using reflect and generated code for marshalling and unmarshalling of protocol buffers") + fmt.Println("$GOROOT/misc/benchcmp marshal.txt marshaler.txt") + fmt.Println("$GOROOT/misc/benchcmp unmarshal.txt unmarshaler.txt") + fmt.Println("$GOROOT/misc/benchcmp marshal.txt unsafe_marshaler.txt") + fmt.Println("$GOROOT/misc/benchcmp unmarshal.txt unsafe_unmarshaler.txt") +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/unmarshal.txt b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/unmarshal.txt new file mode 100644 index 0000000000000000000000000000000000000000..2b958fd93d4db3163b1600ec6e24a3e81e85ea8d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/unmarshal.txt @@ -0,0 +1,49 @@ +PASS +BenchmarkNidOptNativeProtoUnmarshal-4 1000000 2006 ns/op 185.44 MB/s +BenchmarkNinOptNativeProtoUnmarshal-4 1000000 1960 ns/op 173.41 MB/s +BenchmarkNidRepNativeProtoUnmarshal-4 50000 36241 ns/op 195.55 MB/s +BenchmarkNinRepNativeProtoUnmarshal-4 50000 35648 ns/op 198.80 MB/s +BenchmarkNidRepPackedNativeProtoUnmarshal-4 100000 18641 ns/op 183.30 MB/s +BenchmarkNinRepPackedNativeProtoUnmarshal-4 100000 18398 ns/op 185.72 MB/s +BenchmarkNidOptStructProtoUnmarshal-4 500000 5938 ns/op 236.92 MB/s +BenchmarkNinOptStructProtoUnmarshal-4 500000 5871 ns/op 216.14 MB/s +BenchmarkNidRepStructProtoUnmarshal-4 50000 46237 ns/op 190.88 MB/s +BenchmarkNinRepStructProtoUnmarshal-4 50000 39915 ns/op 221.12 MB/s +BenchmarkNidEmbeddedStructProtoUnmarshal-4 500000 3946 ns/op 190.56 MB/s +BenchmarkNinEmbeddedStructProtoUnmarshal-4 500000 3997 ns/op 178.35 MB/s +BenchmarkNidNestedStructProtoUnmarshal-4 10000 207132 ns/op 178.61 MB/s +BenchmarkNinNestedStructProtoUnmarshal-4 10000 170116 ns/op 217.33 MB/s +BenchmarkNidOptCustomProtoUnmarshal-4 1000000 2321 ns/op 30.58 MB/s +BenchmarkNinOptCustomProtoUnmarshal-4 1000000 1947 ns/op 34.40 MB/s +BenchmarkNidRepCustomProtoUnmarshal-4 200000 7884 ns/op 22.96 MB/s +BenchmarkNinRepCustomProtoUnmarshal-4 200000 7926 ns/op 22.83 MB/s +BenchmarkNinOptNativeUnionProtoUnmarshal-4 1000000 1242 ns/op 24.94 MB/s +BenchmarkNinOptStructUnionProtoUnmarshal-4 1000000 1550 ns/op 71.58 MB/s +BenchmarkNinEmbeddedStructUnionProtoUnmarshal-4 1000000 2209 ns/op 109.07 MB/s +BenchmarkNinNestedStructUnionProtoUnmarshal-4 1000000 1954 ns/op 67.02 MB/s +BenchmarkTreeProtoUnmarshal-4 1000000 1785 ns/op 141.12 MB/s +BenchmarkOrBranchProtoUnmarshal-4 1000000 2769 ns/op 198.23 MB/s +BenchmarkAndBranchProtoUnmarshal-4 500000 2680 ns/op 204.84 MB/s +BenchmarkLeafProtoUnmarshal-4 1000000 1407 ns/op 171.92 MB/s +BenchmarkDeepTreeProtoUnmarshal-4 1000000 2387 ns/op 124.40 MB/s +BenchmarkADeepBranchProtoUnmarshal-4 1000000 2621 ns/op 127.39 MB/s +BenchmarkAndDeepBranchProtoUnmarshal-4 500000 3853 ns/op 164.79 MB/s +BenchmarkDeepLeafProtoUnmarshal-4 1000000 2027 ns/op 143.02 MB/s +BenchmarkNilProtoUnmarshal-4 1000000 1472 ns/op 23.78 MB/s +BenchmarkNidOptEnumProtoUnmarshal-4 1000000 1597 ns/op 23.16 MB/s +BenchmarkNinOptEnumProtoUnmarshal-4 1000000 1557 ns/op 23.12 MB/s +BenchmarkNidRepEnumProtoUnmarshal-4 1000000 1746 ns/op 24.62 MB/s +BenchmarkNinRepEnumProtoUnmarshal-4 1000000 1779 ns/op 24.16 MB/s +BenchmarkNinOptEnumDefaultProtoUnmarshal-4 1000000 1607 ns/op 22.39 MB/s +BenchmarkAnotherNinOptEnumProtoUnmarshal-4 1000000 1545 ns/op 23.29 MB/s +BenchmarkAnotherNinOptEnumDefaultProtoUnmarshal-4 1000000 1578 ns/op 22.81 MB/s +BenchmarkTimerProtoUnmarshal-4 1000000 1572 ns/op 66.79 MB/s +BenchmarkMyExtendableProtoUnmarshal-4 1000000 2610 ns/op 30.64 MB/s +BenchmarkOtherExtenableProtoUnmarshal-4 500000 3792 ns/op 41.40 MB/s +BenchmarkNestedDefinitionProtoUnmarshal-4 500000 2987 ns/op 152.29 MB/s +BenchmarkNestedDefinition_NestedMessageProtoUnmarshal-4 1000000 1898 ns/op 124.30 MB/s +BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoUnmarshal-4 1000000 1326 ns/op 159.87 MB/s +BenchmarkNestedScopeProtoUnmarshal-4 1000000 2956 ns/op 151.20 MB/s +BenchmarkNinOptNativeDefaultProtoUnmarshal-4 1000000 2244 ns/op 151.45 MB/s +BenchmarkCustomContainerProtoUnmarshal-4 1000000 2652 ns/op 40.71 MB/s +ok github.com/gogo/protobuf/test/mixbench/testdata 167.715s diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/unmarshaler.txt b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/unmarshaler.txt new file mode 100644 index 0000000000000000000000000000000000000000..9c78ef06a29a42b1f8fddabf35c99ea5fa33dd89 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/unmarshaler.txt @@ -0,0 +1,49 @@ +PASS +BenchmarkNidOptNativeProtoUnmarshal-4 2000000 792 ns/op 469.35 MB/s +BenchmarkNinOptNativeProtoUnmarshal-4 1000000 1167 ns/op 291.16 MB/s +BenchmarkNidRepNativeProtoUnmarshal-4 100000 25302 ns/op 280.09 MB/s +BenchmarkNinRepNativeProtoUnmarshal-4 100000 25069 ns/op 282.70 MB/s +BenchmarkNidRepPackedNativeProtoUnmarshal-4 100000 16569 ns/op 206.22 MB/s +BenchmarkNinRepPackedNativeProtoUnmarshal-4 100000 16323 ns/op 209.33 MB/s +BenchmarkNidOptStructProtoUnmarshal-4 1000000 3107 ns/op 452.75 MB/s +BenchmarkNinOptStructProtoUnmarshal-4 500000 3262 ns/op 388.98 MB/s +BenchmarkNidRepStructProtoUnmarshal-4 100000 26090 ns/op 338.28 MB/s +BenchmarkNinRepStructProtoUnmarshal-4 100000 26086 ns/op 338.34 MB/s +BenchmarkNidEmbeddedStructProtoUnmarshal-4 1000000 1785 ns/op 421.14 MB/s +BenchmarkNinEmbeddedStructProtoUnmarshal-4 1000000 1838 ns/op 387.83 MB/s +BenchmarkNidNestedStructProtoUnmarshal-4 10000 119933 ns/op 308.47 MB/s +BenchmarkNinNestedStructProtoUnmarshal-4 10000 106914 ns/op 345.81 MB/s +BenchmarkNidOptCustomProtoUnmarshal-4 5000000 485 ns/op 146.36 MB/s +BenchmarkNinOptCustomProtoUnmarshal-4 5000000 648 ns/op 103.26 MB/s +BenchmarkNidRepCustomProtoUnmarshal-4 1000000 1743 ns/op 103.83 MB/s +BenchmarkNinRepCustomProtoUnmarshal-4 1000000 1766 ns/op 102.44 MB/s +BenchmarkNinOptNativeUnionProtoUnmarshal-4 10000000 187 ns/op 165.31 MB/s +BenchmarkNinOptStructUnionProtoUnmarshal-4 5000000 519 ns/op 213.49 MB/s +BenchmarkNinEmbeddedStructUnionProtoUnmarshal-4 2000000 971 ns/op 247.99 MB/s +BenchmarkNinNestedStructUnionProtoUnmarshal-4 2000000 801 ns/op 163.54 MB/s +BenchmarkTreeProtoUnmarshal-4 2000000 789 ns/op 319.14 MB/s +BenchmarkOrBranchProtoUnmarshal-4 1000000 1553 ns/op 353.47 MB/s +BenchmarkAndBranchProtoUnmarshal-4 1000000 1552 ns/op 353.60 MB/s +BenchmarkLeafProtoUnmarshal-4 5000000 654 ns/op 369.63 MB/s +BenchmarkDeepTreeProtoUnmarshal-4 1000000 1219 ns/op 243.63 MB/s +BenchmarkADeepBranchProtoUnmarshal-4 1000000 1504 ns/op 222.02 MB/s +BenchmarkAndDeepBranchProtoUnmarshal-4 1000000 2327 ns/op 272.88 MB/s +BenchmarkDeepLeafProtoUnmarshal-4 1000000 1083 ns/op 267.74 MB/s +BenchmarkNilProtoUnmarshal-4 5000000 401 ns/op 87.26 MB/s +BenchmarkNidOptEnumProtoUnmarshal-4 5000000 412 ns/op 89.66 MB/s +BenchmarkNinOptEnumProtoUnmarshal-4 5000000 451 ns/op 79.80 MB/s +BenchmarkNidRepEnumProtoUnmarshal-4 5000000 670 ns/op 64.12 MB/s +BenchmarkNinRepEnumProtoUnmarshal-4 5000000 667 ns/op 64.40 MB/s +BenchmarkNinOptEnumDefaultProtoUnmarshal-4 5000000 450 ns/op 79.88 MB/s +BenchmarkAnotherNinOptEnumProtoUnmarshal-4 5000000 449 ns/op 80.15 MB/s +BenchmarkAnotherNinOptEnumDefaultProtoUnmarshal-4 5000000 448 ns/op 80.24 MB/s +BenchmarkTimerProtoUnmarshal-4 5000000 575 ns/op 182.50 MB/s +BenchmarkMyExtendableProtoUnmarshal-4 1000000 1450 ns/op 55.14 MB/s +BenchmarkOtherExtenableProtoUnmarshal-4 1000000 2567 ns/op 61.15 MB/s +BenchmarkNestedDefinitionProtoUnmarshal-4 1000000 1889 ns/op 240.85 MB/s +BenchmarkNestedDefinition_NestedMessageProtoUnmarshal-4 1000000 1080 ns/op 218.42 MB/s +BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoUnmarshal-4 5000000 693 ns/op 305.86 MB/s +BenchmarkNestedScopeProtoUnmarshal-4 1000000 1843 ns/op 242.49 MB/s +BenchmarkNinOptNativeDefaultProtoUnmarshal-4 1000000 1342 ns/op 253.25 MB/s +BenchmarkCustomContainerProtoUnmarshal-4 2000000 831 ns/op 129.82 MB/s +ok github.com/gogo/protobuf/test/mixbench/testdata 170.829s diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/unsafe_marshaler.txt b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/unsafe_marshaler.txt new file mode 100644 index 0000000000000000000000000000000000000000..8cbf22f4fc268708836f17e5bcece45725949258 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/unsafe_marshaler.txt @@ -0,0 +1,49 @@ +PASS +BenchmarkNidOptNativeProtoMarshal-4 5000000 531 ns/op 700.19 MB/s +BenchmarkNinOptNativeProtoMarshal-4 5000000 594 ns/op 572.27 MB/s +BenchmarkNidRepNativeProtoMarshal-4 200000 8087 ns/op 876.29 MB/s +BenchmarkNinRepNativeProtoMarshal-4 500000 8344 ns/op 849.34 MB/s +BenchmarkNidRepPackedNativeProtoMarshal-4 200000 7595 ns/op 449.89 MB/s +BenchmarkNinRepPackedNativeProtoMarshal-4 500000 7342 ns/op 465.38 MB/s +BenchmarkNidOptStructProtoMarshal-4 1000000 1928 ns/op 729.46 MB/s +BenchmarkNinOptStructProtoMarshal-4 1000000 1859 ns/op 682.32 MB/s +BenchmarkNidRepStructProtoMarshal-4 100000 10993 ns/op 802.82 MB/s +BenchmarkNinRepStructProtoMarshal-4 200000 10088 ns/op 874.84 MB/s +BenchmarkNidEmbeddedStructProtoMarshal-4 1000000 1179 ns/op 637.53 MB/s +BenchmarkNinEmbeddedStructProtoMarshal-4 1000000 1077 ns/op 661.58 MB/s +BenchmarkNidNestedStructProtoMarshal-4 50000 53464 ns/op 691.97 MB/s +BenchmarkNinNestedStructProtoMarshal-4 50000 47677 ns/op 775.46 MB/s +BenchmarkNidOptCustomProtoMarshal-4 5000000 303 ns/op 234.13 MB/s +BenchmarkNinOptCustomProtoMarshal-4 10000000 284 ns/op 235.56 MB/s +BenchmarkNidRepCustomProtoMarshal-4 5000000 598 ns/op 302.19 MB/s +BenchmarkNinRepCustomProtoMarshal-4 5000000 593 ns/op 304.87 MB/s +BenchmarkNinOptNativeUnionProtoMarshal-4 10000000 190 ns/op 162.47 MB/s +BenchmarkNinOptStructUnionProtoMarshal-4 5000000 374 ns/op 296.15 MB/s +BenchmarkNinEmbeddedStructUnionProtoMarshal-4 5000000 652 ns/op 369.55 MB/s +BenchmarkNinNestedStructUnionProtoMarshal-4 5000000 474 ns/op 275.97 MB/s +BenchmarkTreeProtoMarshal-4 5000000 567 ns/op 444.16 MB/s +BenchmarkOrBranchProtoMarshal-4 1000000 1007 ns/op 544.72 MB/s +BenchmarkAndBranchProtoMarshal-4 1000000 1061 ns/op 517.27 MB/s +BenchmarkLeafProtoMarshal-4 5000000 511 ns/op 473.41 MB/s +BenchmarkDeepTreeProtoMarshal-4 5000000 716 ns/op 414.59 MB/s +BenchmarkADeepBranchProtoMarshal-4 2000000 811 ns/op 411.60 MB/s +BenchmarkAndDeepBranchProtoMarshal-4 1000000 1324 ns/op 479.34 MB/s +BenchmarkDeepLeafProtoMarshal-4 5000000 636 ns/op 455.66 MB/s +BenchmarkNilProtoMarshal-4 10000000 189 ns/op 184.91 MB/s +BenchmarkNidOptEnumProtoMarshal-4 10000000 211 ns/op 174.55 MB/s +BenchmarkNinOptEnumProtoMarshal-4 10000000 207 ns/op 173.24 MB/s +BenchmarkNidRepEnumProtoMarshal-4 10000000 231 ns/op 185.80 MB/s +BenchmarkNinRepEnumProtoMarshal-4 10000000 230 ns/op 186.79 MB/s +BenchmarkNinOptEnumDefaultProtoMarshal-4 10000000 208 ns/op 172.65 MB/s +BenchmarkAnotherNinOptEnumProtoMarshal-4 10000000 207 ns/op 173.15 MB/s +BenchmarkAnotherNinOptEnumDefaultProtoMarshal-4 10000000 209 ns/op 171.99 MB/s +BenchmarkTimerProtoMarshal-4 5000000 320 ns/op 327.65 MB/s +BenchmarkMyExtendableProtoMarshal-4 5000000 702 ns/op 113.85 MB/s +BenchmarkOtherExtenableProtoMarshal-4 1000000 1329 ns/op 118.07 MB/s +BenchmarkNestedDefinitionProtoMarshal-4 2000000 904 ns/op 502.96 MB/s +BenchmarkNestedDefinition_NestedMessageProtoMarshal-4 5000000 542 ns/op 434.70 MB/s +BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoMarshal-4 5000000 465 ns/op 455.00 MB/s +BenchmarkNestedScopeProtoMarshal-4 2000000 857 ns/op 521.49 MB/s +BenchmarkNinOptNativeDefaultProtoMarshal-4 5000000 734 ns/op 462.95 MB/s +BenchmarkCustomContainerProtoMarshal-4 5000000 378 ns/op 285.67 MB/s +ok github.com/gogo/protobuf/test/mixbench/testdata 192.235s diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/unsafe_unmarshaler.txt b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/unsafe_unmarshaler.txt new file mode 100644 index 0000000000000000000000000000000000000000..9a85e9361b6fd07c09855810ff6c5b580d84f5a7 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/mixbench/unsafe_unmarshaler.txt @@ -0,0 +1,49 @@ +PASS +BenchmarkNidOptNativeProtoUnmarshal-4 2000000 760 ns/op 488.86 MB/s +BenchmarkNinOptNativeProtoUnmarshal-4 1000000 1130 ns/op 300.67 MB/s +BenchmarkNidRepNativeProtoUnmarshal-4 100000 23698 ns/op 299.05 MB/s +BenchmarkNinRepNativeProtoUnmarshal-4 100000 23400 ns/op 302.86 MB/s +BenchmarkNidRepPackedNativeProtoUnmarshal-4 100000 15286 ns/op 223.53 MB/s +BenchmarkNinRepPackedNativeProtoUnmarshal-4 100000 15375 ns/op 222.23 MB/s +BenchmarkNidOptStructProtoUnmarshal-4 1000000 3019 ns/op 466.02 MB/s +BenchmarkNinOptStructProtoUnmarshal-4 500000 3169 ns/op 400.35 MB/s +BenchmarkNidRepStructProtoUnmarshal-4 100000 25167 ns/op 350.69 MB/s +BenchmarkNinRepStructProtoUnmarshal-4 100000 25199 ns/op 350.25 MB/s +BenchmarkNidEmbeddedStructProtoUnmarshal-4 1000000 1714 ns/op 438.65 MB/s +BenchmarkNinEmbeddedStructProtoUnmarshal-4 1000000 1793 ns/op 397.49 MB/s +BenchmarkNidNestedStructProtoUnmarshal-4 10000 115531 ns/op 320.22 MB/s +BenchmarkNinNestedStructProtoUnmarshal-4 10000 109260 ns/op 338.39 MB/s +BenchmarkNidOptCustomProtoUnmarshal-4 5000000 487 ns/op 145.63 MB/s +BenchmarkNinOptCustomProtoUnmarshal-4 5000000 644 ns/op 103.94 MB/s +BenchmarkNidRepCustomProtoUnmarshal-4 1000000 1733 ns/op 104.42 MB/s +BenchmarkNinRepCustomProtoUnmarshal-4 1000000 1734 ns/op 104.34 MB/s +BenchmarkNinOptNativeUnionProtoUnmarshal-4 10000000 186 ns/op 166.02 MB/s +BenchmarkNinOptStructUnionProtoUnmarshal-4 5000000 512 ns/op 216.66 MB/s +BenchmarkNinEmbeddedStructUnionProtoUnmarshal-4 2000000 954 ns/op 252.56 MB/s +BenchmarkNinNestedStructUnionProtoUnmarshal-4 2000000 788 ns/op 166.15 MB/s +BenchmarkTreeProtoUnmarshal-4 2000000 790 ns/op 318.98 MB/s +BenchmarkOrBranchProtoUnmarshal-4 1000000 1553 ns/op 353.43 MB/s +BenchmarkAndBranchProtoUnmarshal-4 1000000 1554 ns/op 353.09 MB/s +BenchmarkLeafProtoUnmarshal-4 5000000 642 ns/op 376.78 MB/s +BenchmarkDeepTreeProtoUnmarshal-4 1000000 1236 ns/op 240.13 MB/s +BenchmarkADeepBranchProtoUnmarshal-4 1000000 1493 ns/op 223.62 MB/s +BenchmarkAndDeepBranchProtoUnmarshal-4 1000000 2327 ns/op 272.81 MB/s +BenchmarkDeepLeafProtoUnmarshal-4 1000000 1068 ns/op 271.46 MB/s +BenchmarkNilProtoUnmarshal-4 5000000 396 ns/op 88.30 MB/s +BenchmarkNidOptEnumProtoUnmarshal-4 5000000 410 ns/op 90.10 MB/s +BenchmarkNinOptEnumProtoUnmarshal-4 5000000 448 ns/op 80.25 MB/s +BenchmarkNidRepEnumProtoUnmarshal-4 5000000 672 ns/op 63.91 MB/s +BenchmarkNinRepEnumProtoUnmarshal-4 5000000 667 ns/op 64.38 MB/s +BenchmarkNinOptEnumDefaultProtoUnmarshal-4 5000000 446 ns/op 80.63 MB/s +BenchmarkAnotherNinOptEnumProtoUnmarshal-4 5000000 449 ns/op 80.09 MB/s +BenchmarkAnotherNinOptEnumDefaultProtoUnmarshal-4 5000000 449 ns/op 80.08 MB/s +BenchmarkTimerProtoUnmarshal-4 5000000 554 ns/op 189.24 MB/s +BenchmarkMyExtendableProtoUnmarshal-4 1000000 1445 ns/op 55.36 MB/s +BenchmarkOtherExtenableProtoUnmarshal-4 1000000 2544 ns/op 61.70 MB/s +BenchmarkNestedDefinitionProtoUnmarshal-4 1000000 1847 ns/op 246.34 MB/s +BenchmarkNestedDefinition_NestedMessageProtoUnmarshal-4 1000000 1071 ns/op 220.23 MB/s +BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoUnmarshal-4 5000000 688 ns/op 308.09 MB/s +BenchmarkNestedScopeProtoUnmarshal-4 1000000 1803 ns/op 247.86 MB/s +BenchmarkNinOptNativeDefaultProtoUnmarshal-4 1000000 1330 ns/op 255.61 MB/s +BenchmarkCustomContainerProtoUnmarshal-4 2000000 803 ns/op 134.48 MB/s +ok github.com/gogo/protobuf/test/mixbench/testdata 168.327s diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/moredefaults/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/moredefaults/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..c7bd3032323cb1559b4915136440601d4484a971 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/moredefaults/Makefile @@ -0,0 +1,30 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. md.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/moredefaults/md.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/moredefaults/md.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..63bcaf589cd3ae0555d3b712e7952246dd771253 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/moredefaults/md.pb.go @@ -0,0 +1,300 @@ +// Code generated by protoc-gen-gogo. +// source: md.proto +// DO NOT EDIT! + +/* + Package moredefaults is a generated protocol buffer package. + + It is generated from these files: + md.proto + + It has these top-level messages: + MoreDefaultsB + MoreDefaultsA +*/ +package moredefaults + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" +import test "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/example" + +import bytes "bytes" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type MoreDefaultsB struct { + Field1 *string `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MoreDefaultsB) Reset() { *m = MoreDefaultsB{} } +func (m *MoreDefaultsB) String() string { return proto.CompactTextString(m) } +func (*MoreDefaultsB) ProtoMessage() {} + +func (m *MoreDefaultsB) GetField1() string { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return "" +} + +type MoreDefaultsA struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1,def=1234" json:"Field1,omitempty"` + Field2 int64 `protobuf:"varint,2,opt,name=Field2" json:"Field2"` + B1 *MoreDefaultsB `protobuf:"bytes,3,opt,name=B1" json:"B1,omitempty"` + B2 MoreDefaultsB `protobuf:"bytes,4,opt,name=B2" json:"B2"` + A1 *test.A `protobuf:"bytes,5,opt,name=A1" json:"A1,omitempty"` + A2 test.A `protobuf:"bytes,6,opt,name=A2" json:"A2"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MoreDefaultsA) Reset() { *m = MoreDefaultsA{} } +func (m *MoreDefaultsA) String() string { return proto.CompactTextString(m) } +func (*MoreDefaultsA) ProtoMessage() {} + +const Default_MoreDefaultsA_Field1 int64 = 1234 + +func (m *MoreDefaultsA) GetField1() int64 { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_MoreDefaultsA_Field1 +} + +func (m *MoreDefaultsA) GetField2() int64 { + if m != nil { + return m.Field2 + } + return 0 +} + +func (m *MoreDefaultsA) GetB1() *MoreDefaultsB { + if m != nil { + return m.B1 + } + return nil +} + +func (m *MoreDefaultsA) GetB2() MoreDefaultsB { + if m != nil { + return m.B2 + } + return MoreDefaultsB{} +} + +func (m *MoreDefaultsA) GetA1() *test.A { + if m != nil { + return m.A1 + } + return nil +} + +func (m *MoreDefaultsA) GetA2() test.A { + if m != nil { + return m.A2 + } + return test.A{} +} + +func (this *MoreDefaultsB) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*MoreDefaultsB) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *MoreDefaultsA) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*MoreDefaultsA) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + if !this.B1.Equal(that1.B1) { + return false + } + if !this.B2.Equal(&that1.B2) { + return false + } + if !this.A1.Equal(that1.A1) { + return false + } + if !this.A2.Equal(&that1.A2) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func NewPopulatedMoreDefaultsB(r randyMd, easy bool) *MoreDefaultsB { + this := &MoreDefaultsB{} + if r.Intn(10) != 0 { + v1 := randStringMd(r) + this.Field1 = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedMd(r, 2) + } + return this +} + +func NewPopulatedMoreDefaultsA(r randyMd, easy bool) *MoreDefaultsA { + this := &MoreDefaultsA{} + if r.Intn(10) != 0 { + v2 := int64(r.Int63()) + if r.Intn(2) == 0 { + v2 *= -1 + } + this.Field1 = &v2 + } + this.Field2 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + if r.Intn(10) != 0 { + this.B1 = NewPopulatedMoreDefaultsB(r, easy) + } + v3 := NewPopulatedMoreDefaultsB(r, easy) + this.B2 = *v3 + if r.Intn(10) != 0 { + this.A1 = test.NewPopulatedA(r, easy) + } + v4 := test.NewPopulatedA(r, easy) + this.A2 = *v4 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedMd(r, 7) + } + return this +} + +type randyMd interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneMd(r randyMd) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringMd(r randyMd) string { + v5 := r.Intn(100) + tmps := make([]rune, v5) + for i := 0; i < v5; i++ { + tmps[i] = randUTF8RuneMd(r) + } + return string(tmps) +} +func randUnrecognizedMd(r randyMd, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldMd(data, r, fieldNumber, wire) + } + return data +} +func randFieldMd(data []byte, r randyMd, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateMd(data, uint64(key)) + v6 := r.Int63() + if r.Intn(2) == 0 { + v6 *= -1 + } + data = encodeVarintPopulateMd(data, uint64(v6)) + case 1: + data = encodeVarintPopulateMd(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateMd(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateMd(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateMd(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateMd(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/moredefaults/md.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/moredefaults/md.proto new file mode 100644 index 0000000000000000000000000000000000000000..55a0d188045baaef3e5594fbffc06ccfd87915c8 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/moredefaults/md.proto @@ -0,0 +1,51 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package moredefaults; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; +import "github.com/gogo/protobuf/test/example/example.proto"; + +option (gogoproto.goproto_getters_all) = true; +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.equal_all) = true; + +message MoreDefaultsB { + optional string Field1 = 1; +} + +message MoreDefaultsA { + optional int64 Field1 = 1 [default=1234]; + optional int64 Field2 = 2 [(gogoproto.nullable) = false]; + optional MoreDefaultsB B1 = 3; + optional MoreDefaultsB B2 = 4 [(gogoproto.nullable) = false]; + optional test.A A1 = 5; + optional test.A A2 = 6 [(gogoproto.nullable) = false]; +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/moredefaults/md_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/moredefaults/md_test.go new file mode 100644 index 0000000000000000000000000000000000000000..4ffea19f564fe21c4bfb802f11b996b2af8e4296 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/moredefaults/md_test.go @@ -0,0 +1,59 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 moredefaults + +import ( + "testing" + + test "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/example" +) + +func TestDefaults(t *testing.T) { + b := MoreDefaultsB{} + aa := test.A{} + a := &MoreDefaultsA{} + b2 := a.GetB2() + a2 := a.GetA2() + if a.GetField1() != 1234 { + t.Fatalf("Field1 wrong") + } + if a.GetField2() != 0 { + t.Fatalf("Field2 wrong") + } + if a.GetB1() != nil { + t.Fatalf("B1 wrong") + } + if b2.GetField1() != b.GetField1() { + t.Fatalf("B2 wrong") + } + if a.GetA1() != nil { + t.Fatalf("A1 wrong") + } + if a2.GetNumber() != aa.GetNumber() { + t.Fatalf("A2 wrong") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/moredefaults/mdpb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/moredefaults/mdpb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..d519677d5452b089a1a381dd3103ba021a7aa21c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/moredefaults/mdpb_test.go @@ -0,0 +1,188 @@ +// Code generated by protoc-gen-gogo. +// source: md.proto +// DO NOT EDIT! + +/* +Package moredefaults is a generated protocol buffer package. + +It is generated from these files: + md.proto + +It has these top-level messages: + MoreDefaultsB + MoreDefaultsA +*/ +package moredefaults + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" +// discarding unused import test "github.com/gogo/protobuf/test/example" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestMoreDefaultsBProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMoreDefaultsB(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MoreDefaultsB{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestMoreDefaultsAProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMoreDefaultsA(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MoreDefaultsA{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestMoreDefaultsBJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMoreDefaultsB(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MoreDefaultsB{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMoreDefaultsAJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMoreDefaultsA(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MoreDefaultsA{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMoreDefaultsBProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMoreDefaultsB(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &MoreDefaultsB{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMoreDefaultsBProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMoreDefaultsB(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &MoreDefaultsB{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMoreDefaultsAProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMoreDefaultsA(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &MoreDefaultsA{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMoreDefaultsAProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMoreDefaultsA(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &MoreDefaultsA{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..b73c7581b1e749f9333858baa9e7bdb5505d53e5 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/Makefile @@ -0,0 +1,31 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/protobuf/gogoproto +# +# 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. +# +# 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: + go install github.com/gogo/protobuf/protoc-gen-combo + protoc-gen-combo --version="2.6.0" --proto_path=../../../../../:../../protobuf/:. one.proto \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/both/one.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/both/one.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..f3f3bc1478432f61ba430c720e434081a079e88e --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/both/one.pb.go @@ -0,0 +1,6627 @@ +// Code generated by protoc-gen-gogo. +// source: combos/both/one.proto +// DO NOT EDIT! + +/* + Package one is a generated protocol buffer package. + + It is generated from these files: + combos/both/one.proto + + It has these top-level messages: + Subby + AllTypesOneOf + TwoOneofs + CustomOneof +*/ +package one + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_custom "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom" +import github_com_gogo_protobuf_test_casttype "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Subby struct { + Sub *string `protobuf:"bytes,1,opt,name=sub" json:"sub,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Subby) Reset() { *m = Subby{} } +func (*Subby) ProtoMessage() {} + +type AllTypesOneOf struct { + // Types that are valid to be assigned to TestOneof: + // *AllTypesOneOf_Field1 + // *AllTypesOneOf_Field2 + // *AllTypesOneOf_Field3 + // *AllTypesOneOf_Field4 + // *AllTypesOneOf_Field5 + // *AllTypesOneOf_Field6 + // *AllTypesOneOf_Field7 + // *AllTypesOneOf_Field8 + // *AllTypesOneOf_Field9 + // *AllTypesOneOf_Field10 + // *AllTypesOneOf_Field11 + // *AllTypesOneOf_Field12 + // *AllTypesOneOf_Field13 + // *AllTypesOneOf_Field14 + // *AllTypesOneOf_Field15 + // *AllTypesOneOf_SubMessage + TestOneof isAllTypesOneOf_TestOneof `protobuf_oneof:"test_oneof"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllTypesOneOf) Reset() { *m = AllTypesOneOf{} } +func (*AllTypesOneOf) ProtoMessage() {} + +type isAllTypesOneOf_TestOneof interface { + isAllTypesOneOf_TestOneof() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} + +type AllTypesOneOf_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,oneof"` +} +type AllTypesOneOf_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,oneof"` +} +type AllTypesOneOf_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,oneof"` +} +type AllTypesOneOf_Field4 struct { + Field4 int64 `protobuf:"varint,4,opt,name=Field4,oneof"` +} +type AllTypesOneOf_Field5 struct { + Field5 uint32 `protobuf:"varint,5,opt,name=Field5,oneof"` +} +type AllTypesOneOf_Field6 struct { + Field6 uint64 `protobuf:"varint,6,opt,name=Field6,oneof"` +} +type AllTypesOneOf_Field7 struct { + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7,oneof"` +} +type AllTypesOneOf_Field8 struct { + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8,oneof"` +} +type AllTypesOneOf_Field9 struct { + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9,oneof"` +} +type AllTypesOneOf_Field10 struct { + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10,oneof"` +} +type AllTypesOneOf_Field11 struct { + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11,oneof"` +} +type AllTypesOneOf_Field12 struct { + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12,oneof"` +} +type AllTypesOneOf_Field13 struct { + Field13 bool `protobuf:"varint,13,opt,name=Field13,oneof"` +} +type AllTypesOneOf_Field14 struct { + Field14 string `protobuf:"bytes,14,opt,name=Field14,oneof"` +} +type AllTypesOneOf_Field15 struct { + Field15 []byte `protobuf:"bytes,15,opt,name=Field15,oneof"` +} +type AllTypesOneOf_SubMessage struct { + SubMessage *Subby `protobuf:"bytes,16,opt,name=sub_message,oneof"` +} + +func (*AllTypesOneOf_Field1) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field2) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field3) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field4) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field5) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field6) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field7) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field8) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field9) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field10) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field11) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field12) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field13) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field14) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field15) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_SubMessage) isAllTypesOneOf_TestOneof() {} + +func (m *AllTypesOneOf) GetTestOneof() isAllTypesOneOf_TestOneof { + if m != nil { + return m.TestOneof + } + return nil +} + +func (m *AllTypesOneOf) GetField1() float64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *AllTypesOneOf) GetField2() float32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *AllTypesOneOf) GetField3() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *AllTypesOneOf) GetField4() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field4); ok { + return x.Field4 + } + return 0 +} + +func (m *AllTypesOneOf) GetField5() uint32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field5); ok { + return x.Field5 + } + return 0 +} + +func (m *AllTypesOneOf) GetField6() uint64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field6); ok { + return x.Field6 + } + return 0 +} + +func (m *AllTypesOneOf) GetField7() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field7); ok { + return x.Field7 + } + return 0 +} + +func (m *AllTypesOneOf) GetField8() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field8); ok { + return x.Field8 + } + return 0 +} + +func (m *AllTypesOneOf) GetField9() uint32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field9); ok { + return x.Field9 + } + return 0 +} + +func (m *AllTypesOneOf) GetField10() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field10); ok { + return x.Field10 + } + return 0 +} + +func (m *AllTypesOneOf) GetField11() uint64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field11); ok { + return x.Field11 + } + return 0 +} + +func (m *AllTypesOneOf) GetField12() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field12); ok { + return x.Field12 + } + return 0 +} + +func (m *AllTypesOneOf) GetField13() bool { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field13); ok { + return x.Field13 + } + return false +} + +func (m *AllTypesOneOf) GetField14() string { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field14); ok { + return x.Field14 + } + return "" +} + +func (m *AllTypesOneOf) GetField15() []byte { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field15); ok { + return x.Field15 + } + return nil +} + +func (m *AllTypesOneOf) GetSubMessage() *Subby { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_SubMessage); ok { + return x.SubMessage + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*AllTypesOneOf) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _AllTypesOneOf_OneofMarshaler, _AllTypesOneOf_OneofUnmarshaler, []interface{}{ + (*AllTypesOneOf_Field1)(nil), + (*AllTypesOneOf_Field2)(nil), + (*AllTypesOneOf_Field3)(nil), + (*AllTypesOneOf_Field4)(nil), + (*AllTypesOneOf_Field5)(nil), + (*AllTypesOneOf_Field6)(nil), + (*AllTypesOneOf_Field7)(nil), + (*AllTypesOneOf_Field8)(nil), + (*AllTypesOneOf_Field9)(nil), + (*AllTypesOneOf_Field10)(nil), + (*AllTypesOneOf_Field11)(nil), + (*AllTypesOneOf_Field12)(nil), + (*AllTypesOneOf_Field13)(nil), + (*AllTypesOneOf_Field14)(nil), + (*AllTypesOneOf_Field15)(nil), + (*AllTypesOneOf_SubMessage)(nil), + } +} + +func _AllTypesOneOf_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*AllTypesOneOf) + // test_oneof + switch x := m.TestOneof.(type) { + case *AllTypesOneOf_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *AllTypesOneOf_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *AllTypesOneOf_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case *AllTypesOneOf_Field4: + _ = b.EncodeVarint(4<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field4)) + case *AllTypesOneOf_Field5: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field5)) + case *AllTypesOneOf_Field6: + _ = b.EncodeVarint(6<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field6)) + case *AllTypesOneOf_Field7: + _ = b.EncodeVarint(7<<3 | proto.WireVarint) + _ = b.EncodeZigzag32(uint64(x.Field7)) + case *AllTypesOneOf_Field8: + _ = b.EncodeVarint(8<<3 | proto.WireVarint) + _ = b.EncodeZigzag64(uint64(x.Field8)) + case *AllTypesOneOf_Field9: + _ = b.EncodeVarint(9<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field9)) + case *AllTypesOneOf_Field10: + _ = b.EncodeVarint(10<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field10)) + case *AllTypesOneOf_Field11: + _ = b.EncodeVarint(11<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field11)) + case *AllTypesOneOf_Field12: + _ = b.EncodeVarint(12<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field12)) + case *AllTypesOneOf_Field13: + t := uint64(0) + if x.Field13 { + t = 1 + } + _ = b.EncodeVarint(13<<3 | proto.WireVarint) + _ = b.EncodeVarint(t) + case *AllTypesOneOf_Field14: + _ = b.EncodeVarint(14<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field14) + case *AllTypesOneOf_Field15: + _ = b.EncodeVarint(15<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field15) + case *AllTypesOneOf_SubMessage: + _ = b.EncodeVarint(16<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("AllTypesOneOf.TestOneof has unexpected type %T", x) + } + return nil +} + +func _AllTypesOneOf_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*AllTypesOneOf) + switch tag { + case 1: // test_oneof.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field1{math.Float64frombits(x)} + return true, err + case 2: // test_oneof.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // test_oneof.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field3{int32(x)} + return true, err + case 4: // test_oneof.Field4 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field4{int64(x)} + return true, err + case 5: // test_oneof.Field5 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field5{uint32(x)} + return true, err + case 6: // test_oneof.Field6 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field6{x} + return true, err + case 7: // test_oneof.Field7 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag32() + m.TestOneof = &AllTypesOneOf_Field7{int32(x)} + return true, err + case 8: // test_oneof.Field8 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag64() + m.TestOneof = &AllTypesOneOf_Field8{int64(x)} + return true, err + case 9: // test_oneof.Field9 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field9{uint32(x)} + return true, err + case 10: // test_oneof.Field10 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field10{int32(x)} + return true, err + case 11: // test_oneof.Field11 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field11{x} + return true, err + case 12: // test_oneof.Field12 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field12{int64(x)} + return true, err + case 13: // test_oneof.Field13 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field13{x != 0} + return true, err + case 14: // test_oneof.Field14 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.TestOneof = &AllTypesOneOf_Field14{x} + return true, err + case 15: // test_oneof.Field15 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.TestOneof = &AllTypesOneOf_Field15{x} + return true, err + case 16: // test_oneof.sub_message + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.TestOneof = &AllTypesOneOf_SubMessage{msg} + return true, err + default: + return false, nil + } +} + +type TwoOneofs struct { + // Types that are valid to be assigned to One: + // *TwoOneofs_Field1 + // *TwoOneofs_Field2 + // *TwoOneofs_Field3 + One isTwoOneofs_One `protobuf_oneof:"one"` + // Types that are valid to be assigned to Two: + // *TwoOneofs_Field34 + // *TwoOneofs_Field35 + // *TwoOneofs_SubMessage2 + Two isTwoOneofs_Two `protobuf_oneof:"two"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TwoOneofs) Reset() { *m = TwoOneofs{} } +func (*TwoOneofs) ProtoMessage() {} + +type isTwoOneofs_One interface { + isTwoOneofs_One() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} +type isTwoOneofs_Two interface { + isTwoOneofs_Two() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} + +type TwoOneofs_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,oneof"` +} +type TwoOneofs_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,oneof"` +} +type TwoOneofs_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,oneof"` +} +type TwoOneofs_Field34 struct { + Field34 string `protobuf:"bytes,34,opt,name=Field34,oneof"` +} +type TwoOneofs_Field35 struct { + Field35 []byte `protobuf:"bytes,35,opt,name=Field35,oneof"` +} +type TwoOneofs_SubMessage2 struct { + SubMessage2 *Subby `protobuf:"bytes,36,opt,name=sub_message2,oneof"` +} + +func (*TwoOneofs_Field1) isTwoOneofs_One() {} +func (*TwoOneofs_Field2) isTwoOneofs_One() {} +func (*TwoOneofs_Field3) isTwoOneofs_One() {} +func (*TwoOneofs_Field34) isTwoOneofs_Two() {} +func (*TwoOneofs_Field35) isTwoOneofs_Two() {} +func (*TwoOneofs_SubMessage2) isTwoOneofs_Two() {} + +func (m *TwoOneofs) GetOne() isTwoOneofs_One { + if m != nil { + return m.One + } + return nil +} +func (m *TwoOneofs) GetTwo() isTwoOneofs_Two { + if m != nil { + return m.Two + } + return nil +} + +func (m *TwoOneofs) GetField1() float64 { + if x, ok := m.GetOne().(*TwoOneofs_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *TwoOneofs) GetField2() float32 { + if x, ok := m.GetOne().(*TwoOneofs_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *TwoOneofs) GetField3() int32 { + if x, ok := m.GetOne().(*TwoOneofs_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *TwoOneofs) GetField34() string { + if x, ok := m.GetTwo().(*TwoOneofs_Field34); ok { + return x.Field34 + } + return "" +} + +func (m *TwoOneofs) GetField35() []byte { + if x, ok := m.GetTwo().(*TwoOneofs_Field35); ok { + return x.Field35 + } + return nil +} + +func (m *TwoOneofs) GetSubMessage2() *Subby { + if x, ok := m.GetTwo().(*TwoOneofs_SubMessage2); ok { + return x.SubMessage2 + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*TwoOneofs) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _TwoOneofs_OneofMarshaler, _TwoOneofs_OneofUnmarshaler, []interface{}{ + (*TwoOneofs_Field1)(nil), + (*TwoOneofs_Field2)(nil), + (*TwoOneofs_Field3)(nil), + (*TwoOneofs_Field34)(nil), + (*TwoOneofs_Field35)(nil), + (*TwoOneofs_SubMessage2)(nil), + } +} + +func _TwoOneofs_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*TwoOneofs) + // one + switch x := m.One.(type) { + case *TwoOneofs_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *TwoOneofs_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *TwoOneofs_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case nil: + default: + return fmt.Errorf("TwoOneofs.One has unexpected type %T", x) + } + // two + switch x := m.Two.(type) { + case *TwoOneofs_Field34: + _ = b.EncodeVarint(34<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field34) + case *TwoOneofs_Field35: + _ = b.EncodeVarint(35<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field35) + case *TwoOneofs_SubMessage2: + _ = b.EncodeVarint(36<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage2); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("TwoOneofs.Two has unexpected type %T", x) + } + return nil +} + +func _TwoOneofs_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*TwoOneofs) + switch tag { + case 1: // one.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.One = &TwoOneofs_Field1{math.Float64frombits(x)} + return true, err + case 2: // one.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.One = &TwoOneofs_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // one.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.One = &TwoOneofs_Field3{int32(x)} + return true, err + case 34: // two.Field34 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Two = &TwoOneofs_Field34{x} + return true, err + case 35: // two.Field35 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.Two = &TwoOneofs_Field35{x} + return true, err + case 36: // two.sub_message2 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.Two = &TwoOneofs_SubMessage2{msg} + return true, err + default: + return false, nil + } +} + +type CustomOneof struct { + // Types that are valid to be assigned to Custom: + // *CustomOneof_Stringy + // *CustomOneof_CustomType + // *CustomOneof_CastType + // *CustomOneof_MyCustomName + Custom isCustomOneof_Custom `protobuf_oneof:"custom"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomOneof) Reset() { *m = CustomOneof{} } +func (*CustomOneof) ProtoMessage() {} + +type isCustomOneof_Custom interface { + isCustomOneof_Custom() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} + +type CustomOneof_Stringy struct { + Stringy string `protobuf:"bytes,34,opt,name=Stringy,oneof"` +} +type CustomOneof_CustomType struct { + CustomType github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,35,opt,name=CustomType,oneof,customtype=github.com/gogo/protobuf/test/custom.Uint128"` +} +type CustomOneof_CastType struct { + CastType github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,36,opt,name=CastType,oneof,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type"` +} +type CustomOneof_MyCustomName struct { + MyCustomName int64 `protobuf:"varint,37,opt,name=CustomName,oneof"` +} + +func (*CustomOneof_Stringy) isCustomOneof_Custom() {} +func (*CustomOneof_CustomType) isCustomOneof_Custom() {} +func (*CustomOneof_CastType) isCustomOneof_Custom() {} +func (*CustomOneof_MyCustomName) isCustomOneof_Custom() {} + +func (m *CustomOneof) GetCustom() isCustomOneof_Custom { + if m != nil { + return m.Custom + } + return nil +} + +func (m *CustomOneof) GetStringy() string { + if x, ok := m.GetCustom().(*CustomOneof_Stringy); ok { + return x.Stringy + } + return "" +} + +func (m *CustomOneof) GetCastType() github_com_gogo_protobuf_test_casttype.MyUint64Type { + if x, ok := m.GetCustom().(*CustomOneof_CastType); ok { + return x.CastType + } + return 0 +} + +func (m *CustomOneof) GetMyCustomName() int64 { + if x, ok := m.GetCustom().(*CustomOneof_MyCustomName); ok { + return x.MyCustomName + } + return 0 +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*CustomOneof) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _CustomOneof_OneofMarshaler, _CustomOneof_OneofUnmarshaler, []interface{}{ + (*CustomOneof_Stringy)(nil), + (*CustomOneof_CustomType)(nil), + (*CustomOneof_CastType)(nil), + (*CustomOneof_MyCustomName)(nil), + } +} + +func _CustomOneof_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*CustomOneof) + // custom + switch x := m.Custom.(type) { + case *CustomOneof_Stringy: + _ = b.EncodeVarint(34<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Stringy) + case *CustomOneof_CustomType: + _ = b.EncodeVarint(35<<3 | proto.WireBytes) + data, err := x.CustomType.Marshal() + if err != nil { + return err + } + _ = b.EncodeRawBytes(data) + case *CustomOneof_CastType: + _ = b.EncodeVarint(36<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.CastType)) + case *CustomOneof_MyCustomName: + _ = b.EncodeVarint(37<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.MyCustomName)) + case nil: + default: + return fmt.Errorf("CustomOneof.Custom has unexpected type %T", x) + } + return nil +} + +func _CustomOneof_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*CustomOneof) + switch tag { + case 34: // custom.Stringy + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Custom = &CustomOneof_Stringy{x} + return true, err + case 35: // custom.CustomType + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + if err != nil { + return true, err + } + var cc github_com_gogo_protobuf_test_custom.Uint128 + c := &cc + err = c.Unmarshal(x) + m.Custom = &CustomOneof_CustomType{*c} + return true, err + case 36: // custom.CastType + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Custom = &CustomOneof_CastType{github_com_gogo_protobuf_test_casttype.MyUint64Type(x)} + return true, err + case 37: // custom.CustomName + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Custom = &CustomOneof_MyCustomName{int64(x)} + return true, err + default: + return false, nil + } +} + +func (this *Subby) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *AllTypesOneOf) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *TwoOneofs) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *CustomOneof) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func OneDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/both/one.proto"), + Package: func(v string) *string { return &v }("one"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Subby"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("sub"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("AllTypesOneOf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("sub_message"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(0), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("test_oneof")}}, + }, {Name: func(v string) *string { return &v }("TwoOneofs"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field34"), + Number: func(v int32) *int32 { return &v }(34), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("Field35"), + Number: func(v int32) *int32 { return &v }(35), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("sub_message2"), + Number: func(v int32) *int32 { return &v }(36), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(1), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("one")}, {Name: func(v string) *string { return &v }("two")}}, + }, {Name: func(v string) *string { return &v }("CustomOneof"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Stringy"), + Number: func(v int32) *int32 { return &v }(34), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CustomType"), + Number: func(v int32) *int32 { return &v }(35), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }, {Name: func(v string) *string { return &v }("CastType"), + Number: func(v int32) *int32 { return &v }(36), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("CustomName"), + Number: func(v int32) *int32 { return &v }(37), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0xc, 0x4d, 0x79, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4e, 0x61, 0x6d, 0x65})}}, + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("custom")}}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (this *Subby) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Subby) + if !ok { + return fmt.Errorf("that is not of type *Subby") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Subby but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Subbybut is not nil && this == nil") + } + if this.Sub != nil && that1.Sub != nil { + if *this.Sub != *that1.Sub { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", *this.Sub, *that1.Sub) + } + } else if this.Sub != nil { + return fmt.Errorf("this.Sub == nil && that.Sub != nil") + } else if that1.Sub != nil { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Subby) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Subby) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Sub != nil && that1.Sub != nil { + if *this.Sub != *that1.Sub { + return false + } + } else if this.Sub != nil { + return false + } else if that1.Sub != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllTypesOneOf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOfbut is not nil && this == nil") + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return fmt.Errorf("this.TestOneof != nil && that1.TestOneof == nil") + } + } else if this.TestOneof == nil { + return fmt.Errorf("this.TestOneof == nil && that1.TestOneof != nil") + } else if err := this.TestOneof.VerboseEqual(that1.TestOneof); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AllTypesOneOf_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field1) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *AllTypesOneOf_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field2) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *AllTypesOneOf_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field3) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *AllTypesOneOf_Field4) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field4) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field4") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field4 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field4but is not nil && this == nil") + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + return nil +} +func (this *AllTypesOneOf_Field5) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field5) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field5") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field5 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field5but is not nil && this == nil") + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + return nil +} +func (this *AllTypesOneOf_Field6) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field6) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field6") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field6 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field6but is not nil && this == nil") + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + return nil +} +func (this *AllTypesOneOf_Field7) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field7) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field7") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field7 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field7but is not nil && this == nil") + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + return nil +} +func (this *AllTypesOneOf_Field8) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field8) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field8") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field8 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field8but is not nil && this == nil") + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + return nil +} +func (this *AllTypesOneOf_Field9) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field9) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field9") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field9 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field9but is not nil && this == nil") + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + return nil +} +func (this *AllTypesOneOf_Field10) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field10) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field10") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field10 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field10but is not nil && this == nil") + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + return nil +} +func (this *AllTypesOneOf_Field11) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field11) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field11") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field11 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field11but is not nil && this == nil") + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + return nil +} +func (this *AllTypesOneOf_Field12) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field12) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field12") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field12 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field12but is not nil && this == nil") + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + return nil +} +func (this *AllTypesOneOf_Field13) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field13) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field13") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field13 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field13but is not nil && this == nil") + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + return nil +} +func (this *AllTypesOneOf_Field14) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field14) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field14") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field14 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field14but is not nil && this == nil") + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + return nil +} +func (this *AllTypesOneOf_Field15) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field15) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field15") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field15 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field15but is not nil && this == nil") + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + return nil +} +func (this *AllTypesOneOf_SubMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_SubMessage) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_SubMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_SubMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_SubMessagebut is not nil && this == nil") + } + if !this.SubMessage.Equal(that1.SubMessage) { + return fmt.Errorf("SubMessage this(%v) Not Equal that(%v)", this.SubMessage, that1.SubMessage) + } + return nil +} +func (this *AllTypesOneOf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return false + } + } else if this.TestOneof == nil { + return false + } else if !this.TestOneof.Equal(that1.TestOneof) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllTypesOneOf_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *AllTypesOneOf_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *AllTypesOneOf_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *AllTypesOneOf_Field4) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field4) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field4 != that1.Field4 { + return false + } + return true +} +func (this *AllTypesOneOf_Field5) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field5) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field5 != that1.Field5 { + return false + } + return true +} +func (this *AllTypesOneOf_Field6) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field6) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field6 != that1.Field6 { + return false + } + return true +} +func (this *AllTypesOneOf_Field7) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field7) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field7 != that1.Field7 { + return false + } + return true +} +func (this *AllTypesOneOf_Field8) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field8) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field8 != that1.Field8 { + return false + } + return true +} +func (this *AllTypesOneOf_Field9) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field9) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field9 != that1.Field9 { + return false + } + return true +} +func (this *AllTypesOneOf_Field10) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field10) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field10 != that1.Field10 { + return false + } + return true +} +func (this *AllTypesOneOf_Field11) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field11) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field11 != that1.Field11 { + return false + } + return true +} +func (this *AllTypesOneOf_Field12) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field12) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field12 != that1.Field12 { + return false + } + return true +} +func (this *AllTypesOneOf_Field13) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field13) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field13 != that1.Field13 { + return false + } + return true +} +func (this *AllTypesOneOf_Field14) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field14) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field14 != that1.Field14 { + return false + } + return true +} +func (this *AllTypesOneOf_Field15) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field15) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + return true +} +func (this *AllTypesOneOf_SubMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_SubMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage.Equal(that1.SubMessage) { + return false + } + return true +} +func (this *TwoOneofs) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofsbut is not nil && this == nil") + } + if that1.One == nil { + if this.One != nil { + return fmt.Errorf("this.One != nil && that1.One == nil") + } + } else if this.One == nil { + return fmt.Errorf("this.One == nil && that1.One != nil") + } else if err := this.One.VerboseEqual(that1.One); err != nil { + return err + } + if that1.Two == nil { + if this.Two != nil { + return fmt.Errorf("this.Two != nil && that1.Two == nil") + } + } else if this.Two == nil { + return fmt.Errorf("this.Two == nil && that1.Two != nil") + } else if err := this.Two.VerboseEqual(that1.Two); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *TwoOneofs_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field1) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *TwoOneofs_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field2) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *TwoOneofs_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field3) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *TwoOneofs_Field34) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field34) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field34") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field34 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field34but is not nil && this == nil") + } + if this.Field34 != that1.Field34 { + return fmt.Errorf("Field34 this(%v) Not Equal that(%v)", this.Field34, that1.Field34) + } + return nil +} +func (this *TwoOneofs_Field35) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field35) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field35") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field35 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field35but is not nil && this == nil") + } + if !bytes.Equal(this.Field35, that1.Field35) { + return fmt.Errorf("Field35 this(%v) Not Equal that(%v)", this.Field35, that1.Field35) + } + return nil +} +func (this *TwoOneofs_SubMessage2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_SubMessage2) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_SubMessage2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_SubMessage2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_SubMessage2but is not nil && this == nil") + } + if !this.SubMessage2.Equal(that1.SubMessage2) { + return fmt.Errorf("SubMessage2 this(%v) Not Equal that(%v)", this.SubMessage2, that1.SubMessage2) + } + return nil +} +func (this *TwoOneofs) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.One == nil { + if this.One != nil { + return false + } + } else if this.One == nil { + return false + } else if !this.One.Equal(that1.One) { + return false + } + if that1.Two == nil { + if this.Two != nil { + return false + } + } else if this.Two == nil { + return false + } else if !this.Two.Equal(that1.Two) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *TwoOneofs_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *TwoOneofs_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *TwoOneofs_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *TwoOneofs_Field34) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field34) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field34 != that1.Field34 { + return false + } + return true +} +func (this *TwoOneofs_Field35) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field35) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field35, that1.Field35) { + return false + } + return true +} +func (this *TwoOneofs_SubMessage2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_SubMessage2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage2.Equal(that1.SubMessage2) { + return false + } + return true +} +func (this *CustomOneof) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneofbut is not nil && this == nil") + } + if that1.Custom == nil { + if this.Custom != nil { + return fmt.Errorf("this.Custom != nil && that1.Custom == nil") + } + } else if this.Custom == nil { + return fmt.Errorf("this.Custom == nil && that1.Custom != nil") + } else if err := this.Custom.VerboseEqual(that1.Custom); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomOneof_Stringy) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_Stringy) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_Stringy") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_Stringy but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_Stringybut is not nil && this == nil") + } + if this.Stringy != that1.Stringy { + return fmt.Errorf("Stringy this(%v) Not Equal that(%v)", this.Stringy, that1.Stringy) + } + return nil +} +func (this *CustomOneof_CustomType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_CustomType) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_CustomType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_CustomType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_CustomTypebut is not nil && this == nil") + } + if !this.CustomType.Equal(that1.CustomType) { + return fmt.Errorf("CustomType this(%v) Not Equal that(%v)", this.CustomType, that1.CustomType) + } + return nil +} +func (this *CustomOneof_CastType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_CastType) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_CastType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_CastType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_CastTypebut is not nil && this == nil") + } + if this.CastType != that1.CastType { + return fmt.Errorf("CastType this(%v) Not Equal that(%v)", this.CastType, that1.CastType) + } + return nil +} +func (this *CustomOneof_MyCustomName) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_MyCustomName) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_MyCustomName") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_MyCustomName but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_MyCustomNamebut is not nil && this == nil") + } + if this.MyCustomName != that1.MyCustomName { + return fmt.Errorf("MyCustomName this(%v) Not Equal that(%v)", this.MyCustomName, that1.MyCustomName) + } + return nil +} +func (this *CustomOneof) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Custom == nil { + if this.Custom != nil { + return false + } + } else if this.Custom == nil { + return false + } else if !this.Custom.Equal(that1.Custom) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomOneof_Stringy) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_Stringy) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Stringy != that1.Stringy { + return false + } + return true +} +func (this *CustomOneof_CustomType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_CustomType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.CustomType.Equal(that1.CustomType) { + return false + } + return true +} +func (this *CustomOneof_CastType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_CastType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.CastType != that1.CastType { + return false + } + return true +} +func (this *CustomOneof_MyCustomName) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_MyCustomName) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.MyCustomName != that1.MyCustomName { + return false + } + return true +} +func (this *Subby) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&one.Subby{") + if this.Sub != nil { + s = append(s, "Sub: "+valueToGoStringOne(this.Sub, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllTypesOneOf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 20) + s = append(s, "&one.AllTypesOneOf{") + if this.TestOneof != nil { + s = append(s, "TestOneof: "+fmt.Sprintf("%#v", this.TestOneof)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllTypesOneOf_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field4) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field4{` + + `Field4:` + fmt.Sprintf("%#v", this.Field4) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field5) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field5{` + + `Field5:` + fmt.Sprintf("%#v", this.Field5) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field6) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field6{` + + `Field6:` + fmt.Sprintf("%#v", this.Field6) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field7) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field7{` + + `Field7:` + fmt.Sprintf("%#v", this.Field7) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field8) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field8{` + + `Field8:` + fmt.Sprintf("%#v", this.Field8) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field9) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field9{` + + `Field9:` + fmt.Sprintf("%#v", this.Field9) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field10) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field10{` + + `Field10:` + fmt.Sprintf("%#v", this.Field10) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field11) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field11{` + + `Field11:` + fmt.Sprintf("%#v", this.Field11) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field12) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field12{` + + `Field12:` + fmt.Sprintf("%#v", this.Field12) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field13) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field13{` + + `Field13:` + fmt.Sprintf("%#v", this.Field13) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field14) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field14{` + + `Field14:` + fmt.Sprintf("%#v", this.Field14) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field15) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field15{` + + `Field15:` + fmt.Sprintf("%#v", this.Field15) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_SubMessage) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_SubMessage{` + + `SubMessage:` + fmt.Sprintf("%#v", this.SubMessage) + `}`}, ", ") + return s +} +func (this *TwoOneofs) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 10) + s = append(s, "&one.TwoOneofs{") + if this.One != nil { + s = append(s, "One: "+fmt.Sprintf("%#v", this.One)+",\n") + } + if this.Two != nil { + s = append(s, "Two: "+fmt.Sprintf("%#v", this.Two)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *TwoOneofs_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field34) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field34{` + + `Field34:` + fmt.Sprintf("%#v", this.Field34) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field35) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field35{` + + `Field35:` + fmt.Sprintf("%#v", this.Field35) + `}`}, ", ") + return s +} +func (this *TwoOneofs_SubMessage2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_SubMessage2{` + + `SubMessage2:` + fmt.Sprintf("%#v", this.SubMessage2) + `}`}, ", ") + return s +} +func (this *CustomOneof) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&one.CustomOneof{") + if this.Custom != nil { + s = append(s, "Custom: "+fmt.Sprintf("%#v", this.Custom)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomOneof_Stringy) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_Stringy{` + + `Stringy:` + fmt.Sprintf("%#v", this.Stringy) + `}`}, ", ") + return s +} +func (this *CustomOneof_CustomType) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_CustomType{` + + `CustomType:` + fmt.Sprintf("%#v", this.CustomType) + `}`}, ", ") + return s +} +func (this *CustomOneof_CastType) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_CastType{` + + `CastType:` + fmt.Sprintf("%#v", this.CastType) + `}`}, ", ") + return s +} +func (this *CustomOneof_MyCustomName) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_MyCustomName{` + + `MyCustomName:` + fmt.Sprintf("%#v", this.MyCustomName) + `}`}, ", ") + return s +} +func valueToGoStringOne(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringOne(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *Subby) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Subby) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Sub != nil { + data[i] = 0xa + i++ + i = encodeVarintOne(data, i, uint64(len(*m.Sub))) + i += copy(data[i:], *m.Sub) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AllTypesOneOf) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AllTypesOneOf) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.TestOneof != nil { + nn1, err := m.TestOneof.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn1 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AllTypesOneOf_Field1) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x9 + i++ + i = encodeFixed64One(data, i, uint64(math.Float64bits(m.Field1))) + return i, nil +} +func (m *AllTypesOneOf_Field2) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x15 + i++ + i = encodeFixed32One(data, i, uint32(math.Float32bits(m.Field2))) + return i, nil +} +func (m *AllTypesOneOf_Field3) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x18 + i++ + i = encodeVarintOne(data, i, uint64(m.Field3)) + return i, nil +} +func (m *AllTypesOneOf_Field4) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x20 + i++ + i = encodeVarintOne(data, i, uint64(m.Field4)) + return i, nil +} +func (m *AllTypesOneOf_Field5) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x28 + i++ + i = encodeVarintOne(data, i, uint64(m.Field5)) + return i, nil +} +func (m *AllTypesOneOf_Field6) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x30 + i++ + i = encodeVarintOne(data, i, uint64(m.Field6)) + return i, nil +} +func (m *AllTypesOneOf_Field7) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x38 + i++ + i = encodeVarintOne(data, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31)))) + return i, nil +} +func (m *AllTypesOneOf_Field8) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x40 + i++ + i = encodeVarintOne(data, i, uint64((uint64(m.Field8)<<1)^uint64((m.Field8>>63)))) + return i, nil +} +func (m *AllTypesOneOf_Field9) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x4d + i++ + i = encodeFixed32One(data, i, uint32(m.Field9)) + return i, nil +} +func (m *AllTypesOneOf_Field10) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x55 + i++ + i = encodeFixed32One(data, i, uint32(m.Field10)) + return i, nil +} +func (m *AllTypesOneOf_Field11) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x59 + i++ + i = encodeFixed64One(data, i, uint64(m.Field11)) + return i, nil +} +func (m *AllTypesOneOf_Field12) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x61 + i++ + i = encodeFixed64One(data, i, uint64(m.Field12)) + return i, nil +} +func (m *AllTypesOneOf_Field13) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x68 + i++ + if m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + return i, nil +} +func (m *AllTypesOneOf_Field14) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x72 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field14))) + i += copy(data[i:], m.Field14) + return i, nil +} +func (m *AllTypesOneOf_Field15) MarshalTo(data []byte) (int, error) { + i := 0 + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + return i, nil +} +func (m *AllTypesOneOf_SubMessage) MarshalTo(data []byte) (int, error) { + i := 0 + if m.SubMessage != nil { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + i = encodeVarintOne(data, i, uint64(m.SubMessage.Size())) + n2, err := m.SubMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + } + return i, nil +} +func (m *TwoOneofs) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *TwoOneofs) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.One != nil { + nn3, err := m.One.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn3 + } + if m.Two != nil { + nn4, err := m.Two.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn4 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TwoOneofs_Field1) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x9 + i++ + i = encodeFixed64One(data, i, uint64(math.Float64bits(m.Field1))) + return i, nil +} +func (m *TwoOneofs_Field2) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x15 + i++ + i = encodeFixed32One(data, i, uint32(math.Float32bits(m.Field2))) + return i, nil +} +func (m *TwoOneofs_Field3) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x18 + i++ + i = encodeVarintOne(data, i, uint64(m.Field3)) + return i, nil +} +func (m *TwoOneofs_Field34) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x92 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field34))) + i += copy(data[i:], m.Field34) + return i, nil +} +func (m *TwoOneofs_Field35) MarshalTo(data []byte) (int, error) { + i := 0 + if m.Field35 != nil { + data[i] = 0x9a + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field35))) + i += copy(data[i:], m.Field35) + } + return i, nil +} +func (m *TwoOneofs_SubMessage2) MarshalTo(data []byte) (int, error) { + i := 0 + if m.SubMessage2 != nil { + data[i] = 0xa2 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(m.SubMessage2.Size())) + n5, err := m.SubMessage2.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n5 + } + return i, nil +} +func (m *CustomOneof) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomOneof) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Custom != nil { + nn6, err := m.Custom.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn6 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomOneof_Stringy) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x92 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Stringy))) + i += copy(data[i:], m.Stringy) + return i, nil +} +func (m *CustomOneof_CustomType) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x9a + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(m.CustomType.Size())) + n7, err := m.CustomType.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n7 + return i, nil +} +func (m *CustomOneof_CastType) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0xa0 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(m.CastType)) + return i, nil +} +func (m *CustomOneof_MyCustomName) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0xa8 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(m.MyCustomName)) + return i, nil +} +func encodeFixed64One(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32One(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintOne(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedSubby(r randyOne, easy bool) *Subby { + this := &Subby{} + if r.Intn(10) != 0 { + v1 := randStringOne(r) + this.Sub = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 2) + } + return this +} + +func NewPopulatedAllTypesOneOf(r randyOne, easy bool) *AllTypesOneOf { + this := &AllTypesOneOf{} + oneofNumber_TestOneof := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}[r.Intn(16)] + switch oneofNumber_TestOneof { + case 1: + this.TestOneof = NewPopulatedAllTypesOneOf_Field1(r, easy) + case 2: + this.TestOneof = NewPopulatedAllTypesOneOf_Field2(r, easy) + case 3: + this.TestOneof = NewPopulatedAllTypesOneOf_Field3(r, easy) + case 4: + this.TestOneof = NewPopulatedAllTypesOneOf_Field4(r, easy) + case 5: + this.TestOneof = NewPopulatedAllTypesOneOf_Field5(r, easy) + case 6: + this.TestOneof = NewPopulatedAllTypesOneOf_Field6(r, easy) + case 7: + this.TestOneof = NewPopulatedAllTypesOneOf_Field7(r, easy) + case 8: + this.TestOneof = NewPopulatedAllTypesOneOf_Field8(r, easy) + case 9: + this.TestOneof = NewPopulatedAllTypesOneOf_Field9(r, easy) + case 10: + this.TestOneof = NewPopulatedAllTypesOneOf_Field10(r, easy) + case 11: + this.TestOneof = NewPopulatedAllTypesOneOf_Field11(r, easy) + case 12: + this.TestOneof = NewPopulatedAllTypesOneOf_Field12(r, easy) + case 13: + this.TestOneof = NewPopulatedAllTypesOneOf_Field13(r, easy) + case 14: + this.TestOneof = NewPopulatedAllTypesOneOf_Field14(r, easy) + case 15: + this.TestOneof = NewPopulatedAllTypesOneOf_Field15(r, easy) + case 16: + this.TestOneof = NewPopulatedAllTypesOneOf_SubMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 17) + } + return this +} + +func NewPopulatedAllTypesOneOf_Field1(r randyOne, easy bool) *AllTypesOneOf_Field1 { + this := &AllTypesOneOf_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field2(r randyOne, easy bool) *AllTypesOneOf_Field2 { + this := &AllTypesOneOf_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field3(r randyOne, easy bool) *AllTypesOneOf_Field3 { + this := &AllTypesOneOf_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field4(r randyOne, easy bool) *AllTypesOneOf_Field4 { + this := &AllTypesOneOf_Field4{} + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field5(r randyOne, easy bool) *AllTypesOneOf_Field5 { + this := &AllTypesOneOf_Field5{} + this.Field5 = uint32(r.Uint32()) + return this +} +func NewPopulatedAllTypesOneOf_Field6(r randyOne, easy bool) *AllTypesOneOf_Field6 { + this := &AllTypesOneOf_Field6{} + this.Field6 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedAllTypesOneOf_Field7(r randyOne, easy bool) *AllTypesOneOf_Field7 { + this := &AllTypesOneOf_Field7{} + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field8(r randyOne, easy bool) *AllTypesOneOf_Field8 { + this := &AllTypesOneOf_Field8{} + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field9(r randyOne, easy bool) *AllTypesOneOf_Field9 { + this := &AllTypesOneOf_Field9{} + this.Field9 = uint32(r.Uint32()) + return this +} +func NewPopulatedAllTypesOneOf_Field10(r randyOne, easy bool) *AllTypesOneOf_Field10 { + this := &AllTypesOneOf_Field10{} + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field11(r randyOne, easy bool) *AllTypesOneOf_Field11 { + this := &AllTypesOneOf_Field11{} + this.Field11 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedAllTypesOneOf_Field12(r randyOne, easy bool) *AllTypesOneOf_Field12 { + this := &AllTypesOneOf_Field12{} + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field13(r randyOne, easy bool) *AllTypesOneOf_Field13 { + this := &AllTypesOneOf_Field13{} + this.Field13 = bool(bool(r.Intn(2) == 0)) + return this +} +func NewPopulatedAllTypesOneOf_Field14(r randyOne, easy bool) *AllTypesOneOf_Field14 { + this := &AllTypesOneOf_Field14{} + this.Field14 = randStringOne(r) + return this +} +func NewPopulatedAllTypesOneOf_Field15(r randyOne, easy bool) *AllTypesOneOf_Field15 { + this := &AllTypesOneOf_Field15{} + v2 := r.Intn(100) + this.Field15 = make([]byte, v2) + for i := 0; i < v2; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedAllTypesOneOf_SubMessage(r randyOne, easy bool) *AllTypesOneOf_SubMessage { + this := &AllTypesOneOf_SubMessage{} + this.SubMessage = NewPopulatedSubby(r, easy) + return this +} +func NewPopulatedTwoOneofs(r randyOne, easy bool) *TwoOneofs { + this := &TwoOneofs{} + oneofNumber_One := []int32{1, 2, 3}[r.Intn(3)] + switch oneofNumber_One { + case 1: + this.One = NewPopulatedTwoOneofs_Field1(r, easy) + case 2: + this.One = NewPopulatedTwoOneofs_Field2(r, easy) + case 3: + this.One = NewPopulatedTwoOneofs_Field3(r, easy) + } + oneofNumber_Two := []int32{34, 35, 36}[r.Intn(3)] + switch oneofNumber_Two { + case 34: + this.Two = NewPopulatedTwoOneofs_Field34(r, easy) + case 35: + this.Two = NewPopulatedTwoOneofs_Field35(r, easy) + case 36: + this.Two = NewPopulatedTwoOneofs_SubMessage2(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 37) + } + return this +} + +func NewPopulatedTwoOneofs_Field1(r randyOne, easy bool) *TwoOneofs_Field1 { + this := &TwoOneofs_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field2(r randyOne, easy bool) *TwoOneofs_Field2 { + this := &TwoOneofs_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field3(r randyOne, easy bool) *TwoOneofs_Field3 { + this := &TwoOneofs_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field34(r randyOne, easy bool) *TwoOneofs_Field34 { + this := &TwoOneofs_Field34{} + this.Field34 = randStringOne(r) + return this +} +func NewPopulatedTwoOneofs_Field35(r randyOne, easy bool) *TwoOneofs_Field35 { + this := &TwoOneofs_Field35{} + v3 := r.Intn(100) + this.Field35 = make([]byte, v3) + for i := 0; i < v3; i++ { + this.Field35[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedTwoOneofs_SubMessage2(r randyOne, easy bool) *TwoOneofs_SubMessage2 { + this := &TwoOneofs_SubMessage2{} + this.SubMessage2 = NewPopulatedSubby(r, easy) + return this +} +func NewPopulatedCustomOneof(r randyOne, easy bool) *CustomOneof { + this := &CustomOneof{} + oneofNumber_Custom := []int32{34, 35, 36, 37}[r.Intn(4)] + switch oneofNumber_Custom { + case 34: + this.Custom = NewPopulatedCustomOneof_Stringy(r, easy) + case 35: + this.Custom = NewPopulatedCustomOneof_CustomType(r, easy) + case 36: + this.Custom = NewPopulatedCustomOneof_CastType(r, easy) + case 37: + this.Custom = NewPopulatedCustomOneof_MyCustomName(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 38) + } + return this +} + +func NewPopulatedCustomOneof_Stringy(r randyOne, easy bool) *CustomOneof_Stringy { + this := &CustomOneof_Stringy{} + this.Stringy = randStringOne(r) + return this +} +func NewPopulatedCustomOneof_CustomType(r randyOne, easy bool) *CustomOneof_CustomType { + this := &CustomOneof_CustomType{} + v4 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.CustomType = *v4 + return this +} +func NewPopulatedCustomOneof_CastType(r randyOne, easy bool) *CustomOneof_CastType { + this := &CustomOneof_CastType{} + this.CastType = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + return this +} +func NewPopulatedCustomOneof_MyCustomName(r randyOne, easy bool) *CustomOneof_MyCustomName { + this := &CustomOneof_MyCustomName{} + this.MyCustomName = int64(r.Int63()) + if r.Intn(2) == 0 { + this.MyCustomName *= -1 + } + return this +} + +type randyOne interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneOne(r randyOne) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringOne(r randyOne) string { + v5 := r.Intn(100) + tmps := make([]rune, v5) + for i := 0; i < v5; i++ { + tmps[i] = randUTF8RuneOne(r) + } + return string(tmps) +} +func randUnrecognizedOne(r randyOne, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldOne(data, r, fieldNumber, wire) + } + return data +} +func randFieldOne(data []byte, r randyOne, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateOne(data, uint64(key)) + v6 := r.Int63() + if r.Intn(2) == 0 { + v6 *= -1 + } + data = encodeVarintPopulateOne(data, uint64(v6)) + case 1: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateOne(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateOne(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateOne(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Subby) Size() (n int) { + var l int + _ = l + if m.Sub != nil { + l = len(*m.Sub) + n += 1 + l + sovOne(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllTypesOneOf) Size() (n int) { + var l int + _ = l + if m.TestOneof != nil { + n += m.TestOneof.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllTypesOneOf_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *AllTypesOneOf_Field4) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field4)) + return n +} +func (m *AllTypesOneOf_Field5) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field5)) + return n +} +func (m *AllTypesOneOf_Field6) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field6)) + return n +} +func (m *AllTypesOneOf_Field7) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field7)) + return n +} +func (m *AllTypesOneOf_Field8) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field8)) + return n +} +func (m *AllTypesOneOf_Field9) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field10) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field11) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field12) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field13) Size() (n int) { + var l int + _ = l + n += 2 + return n +} +func (m *AllTypesOneOf_Field14) Size() (n int) { + var l int + _ = l + l = len(m.Field14) + n += 1 + l + sovOne(uint64(l)) + return n +} +func (m *AllTypesOneOf_Field15) Size() (n int) { + var l int + _ = l + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovOne(uint64(l)) + } + return n +} +func (m *AllTypesOneOf_SubMessage) Size() (n int) { + var l int + _ = l + if m.SubMessage != nil { + l = m.SubMessage.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *TwoOneofs) Size() (n int) { + var l int + _ = l + if m.One != nil { + n += m.One.Size() + } + if m.Two != nil { + n += m.Two.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TwoOneofs_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *TwoOneofs_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *TwoOneofs_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *TwoOneofs_Field34) Size() (n int) { + var l int + _ = l + l = len(m.Field34) + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *TwoOneofs_Field35) Size() (n int) { + var l int + _ = l + if m.Field35 != nil { + l = len(m.Field35) + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *TwoOneofs_SubMessage2) Size() (n int) { + var l int + _ = l + if m.SubMessage2 != nil { + l = m.SubMessage2.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *CustomOneof) Size() (n int) { + var l int + _ = l + if m.Custom != nil { + n += m.Custom.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomOneof_Stringy) Size() (n int) { + var l int + _ = l + l = len(m.Stringy) + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *CustomOneof_CustomType) Size() (n int) { + var l int + _ = l + l = m.CustomType.Size() + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *CustomOneof_CastType) Size() (n int) { + var l int + _ = l + n += 2 + sovOne(uint64(m.CastType)) + return n +} +func (m *CustomOneof_MyCustomName) Size() (n int) { + var l int + _ = l + n += 2 + sovOne(uint64(m.MyCustomName)) + return n +} + +func sovOne(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozOne(x uint64) (n int) { + return sovOne(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Subby) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Subby{`, + `Sub:` + valueToStringOne(this.Sub) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf{`, + `TestOneof:` + fmt.Sprintf("%v", this.TestOneof) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field4) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field4{`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field5) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field5{`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field6) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field6{`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field7) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field7{`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field8) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field8{`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field9) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field9{`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field10) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field10{`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field11) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field11{`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field12) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field12{`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field13) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field13{`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field14) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field14{`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field15) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field15{`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_SubMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_SubMessage{`, + `SubMessage:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs{`, + `One:` + fmt.Sprintf("%v", this.One) + `,`, + `Two:` + fmt.Sprintf("%v", this.Two) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field34) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field34{`, + `Field34:` + fmt.Sprintf("%v", this.Field34) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field35) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field35{`, + `Field35:` + fmt.Sprintf("%v", this.Field35) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_SubMessage2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_SubMessage2{`, + `SubMessage2:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage2), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof{`, + `Custom:` + fmt.Sprintf("%v", this.Custom) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_Stringy) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_Stringy{`, + `Stringy:` + fmt.Sprintf("%v", this.Stringy) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_CustomType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_CustomType{`, + `CustomType:` + fmt.Sprintf("%v", this.CustomType) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_CastType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_CastType{`, + `CastType:` + fmt.Sprintf("%v", this.CastType) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_MyCustomName) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_MyCustomName{`, + `MyCustomName:` + fmt.Sprintf("%v", this.MyCustomName) + `,`, + `}`, + }, "") + return s +} +func valueToStringOne(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Subby) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Subby: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Subby: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sub", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Sub = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOne(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOne + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AllTypesOneOf) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AllTypesOneOf: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AllTypesOneOf: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.TestOneof = &AllTypesOneOf_Field1{float64(math.Float64frombits(v))} + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.TestOneof = &AllTypesOneOf_Field2{float32(math.Float32frombits(v))} + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &AllTypesOneOf_Field3{v} + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &AllTypesOneOf_Field4{v} + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &AllTypesOneOf_Field5{v} + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &AllTypesOneOf_Field6{v} + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.TestOneof = &AllTypesOneOf_Field7{v} + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.TestOneof = &AllTypesOneOf_Field8{int64(v)} + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.TestOneof = &AllTypesOneOf_Field9{v} + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.TestOneof = &AllTypesOneOf_Field10{v} + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.TestOneof = &AllTypesOneOf_Field11{v} + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.TestOneof = &AllTypesOneOf_Field12{v} + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.TestOneof = &AllTypesOneOf_Field13{b} + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TestOneof = &AllTypesOneOf_Field14{string(data[iNdEx:postIndex])} + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := make([]byte, postIndex-iNdEx) + copy(v, data[iNdEx:postIndex]) + m.TestOneof = &AllTypesOneOf_Field15{v} + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &Subby{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.TestOneof = &AllTypesOneOf_SubMessage{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOne(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOne + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TwoOneofs) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TwoOneofs: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TwoOneofs: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.One = &TwoOneofs_Field1{float64(math.Float64frombits(v))} + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.One = &TwoOneofs_Field2{float32(math.Float32frombits(v))} + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.One = &TwoOneofs_Field3{v} + case 34: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field34", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Two = &TwoOneofs_Field34{string(data[iNdEx:postIndex])} + iNdEx = postIndex + case 35: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field35", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := make([]byte, postIndex-iNdEx) + copy(v, data[iNdEx:postIndex]) + m.Two = &TwoOneofs_Field35{v} + iNdEx = postIndex + case 36: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubMessage2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &Subby{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.Two = &TwoOneofs_SubMessage2{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOne(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOne + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomOneof) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomOneof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomOneof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 34: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Stringy", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Custom = &CustomOneof_Stringy{string(data[iNdEx:postIndex])} + iNdEx = postIndex + case 35: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CustomType", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var vv github_com_gogo_protobuf_test_custom.Uint128 + v := &vv + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.Custom = &CustomOneof_CustomType{*v} + iNdEx = postIndex + case 36: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CastType", wireType) + } + var v github_com_gogo_protobuf_test_casttype.MyUint64Type + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (github_com_gogo_protobuf_test_casttype.MyUint64Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Custom = &CustomOneof_CastType{v} + case 37: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyCustomName", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Custom = &CustomOneof_MyCustomName{v} + default: + iNdEx = preIndex + skippy, err := skipOne(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOne + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipOne(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOne + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOne + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOne + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthOne + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOne + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipOne(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthOne = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowOne = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/both/one.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/both/one.proto new file mode 100644 index 0000000000000000000000000000000000000000..9f36cf72220a68b7058547869c5456c31d27af12 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/both/one.proto @@ -0,0 +1,101 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package one; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Subby { + optional string sub = 1; +} + +message AllTypesOneOf { + oneof test_oneof { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + int64 Field4 = 4; + uint32 Field5 = 5; + uint64 Field6 = 6; + sint32 Field7 = 7; + sint64 Field8 = 8; + fixed32 Field9 = 9; + sfixed32 Field10 = 10; + fixed64 Field11 = 11; + sfixed64 Field12 = 12; + bool Field13 = 13; + string Field14 = 14; + bytes Field15 = 15; + Subby sub_message = 16; + } +} + +message TwoOneofs { + oneof one { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + } + + oneof two { + string Field34 = 34; + bytes Field35 = 35; + Subby sub_message2 = 36; + } +} + +message CustomOneof { + oneof custom { + string Stringy = 34; + bytes CustomType = 35 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; + uint64 CastType = 36 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + int64 CustomName = 37 [(gogoproto.customname) = "MyCustomName"]; + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/both/onepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/both/onepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..27a37ac4a42759b0890dc371c4fff830b95c50ee --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/both/onepb_test.go @@ -0,0 +1,744 @@ +// Code generated by protoc-gen-gogo. +// source: combos/both/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/both/one.proto + +It has these top-level messages: + Subby + AllTypesOneOf + TwoOneofs + CustomOneof +*/ +package one + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestSubbyProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSubbyMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAllTypesOneOfMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestTwoOneofsMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomOneofMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllTypesOneOfJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTwoOneofsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomOneofJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSubbyProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOneDescription(t *testing.T) { + OneDescription() +} +func TestSubbyVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllTypesOneOfVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTwoOneofsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomOneofVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSubbyGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllTypesOneOfGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTwoOneofsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomOneofGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSubbySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestAllTypesOneOfSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestTwoOneofsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestCustomOneofSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSubbyStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllTypesOneOfStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTwoOneofsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomOneofStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/marshaler/one.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/marshaler/one.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..fb0bfd4a449015fc4052e2cafb00a15d433ed734 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/marshaler/one.pb.go @@ -0,0 +1,5712 @@ +// Code generated by protoc-gen-gogo. +// source: combos/marshaler/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/marshaler/one.proto + +It has these top-level messages: + Subby + AllTypesOneOf + TwoOneofs + CustomOneof +*/ +package one + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_custom "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom" +import github_com_gogo_protobuf_test_casttype "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Subby struct { + Sub *string `protobuf:"bytes,1,opt,name=sub" json:"sub,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Subby) Reset() { *m = Subby{} } +func (*Subby) ProtoMessage() {} + +type AllTypesOneOf struct { + // Types that are valid to be assigned to TestOneof: + // *AllTypesOneOf_Field1 + // *AllTypesOneOf_Field2 + // *AllTypesOneOf_Field3 + // *AllTypesOneOf_Field4 + // *AllTypesOneOf_Field5 + // *AllTypesOneOf_Field6 + // *AllTypesOneOf_Field7 + // *AllTypesOneOf_Field8 + // *AllTypesOneOf_Field9 + // *AllTypesOneOf_Field10 + // *AllTypesOneOf_Field11 + // *AllTypesOneOf_Field12 + // *AllTypesOneOf_Field13 + // *AllTypesOneOf_Field14 + // *AllTypesOneOf_Field15 + // *AllTypesOneOf_SubMessage + TestOneof isAllTypesOneOf_TestOneof `protobuf_oneof:"test_oneof"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllTypesOneOf) Reset() { *m = AllTypesOneOf{} } +func (*AllTypesOneOf) ProtoMessage() {} + +type isAllTypesOneOf_TestOneof interface { + isAllTypesOneOf_TestOneof() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} + +type AllTypesOneOf_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,oneof"` +} +type AllTypesOneOf_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,oneof"` +} +type AllTypesOneOf_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,oneof"` +} +type AllTypesOneOf_Field4 struct { + Field4 int64 `protobuf:"varint,4,opt,name=Field4,oneof"` +} +type AllTypesOneOf_Field5 struct { + Field5 uint32 `protobuf:"varint,5,opt,name=Field5,oneof"` +} +type AllTypesOneOf_Field6 struct { + Field6 uint64 `protobuf:"varint,6,opt,name=Field6,oneof"` +} +type AllTypesOneOf_Field7 struct { + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7,oneof"` +} +type AllTypesOneOf_Field8 struct { + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8,oneof"` +} +type AllTypesOneOf_Field9 struct { + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9,oneof"` +} +type AllTypesOneOf_Field10 struct { + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10,oneof"` +} +type AllTypesOneOf_Field11 struct { + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11,oneof"` +} +type AllTypesOneOf_Field12 struct { + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12,oneof"` +} +type AllTypesOneOf_Field13 struct { + Field13 bool `protobuf:"varint,13,opt,name=Field13,oneof"` +} +type AllTypesOneOf_Field14 struct { + Field14 string `protobuf:"bytes,14,opt,name=Field14,oneof"` +} +type AllTypesOneOf_Field15 struct { + Field15 []byte `protobuf:"bytes,15,opt,name=Field15,oneof"` +} +type AllTypesOneOf_SubMessage struct { + SubMessage *Subby `protobuf:"bytes,16,opt,name=sub_message,oneof"` +} + +func (*AllTypesOneOf_Field1) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field2) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field3) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field4) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field5) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field6) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field7) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field8) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field9) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field10) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field11) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field12) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field13) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field14) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field15) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_SubMessage) isAllTypesOneOf_TestOneof() {} + +func (m *AllTypesOneOf) GetTestOneof() isAllTypesOneOf_TestOneof { + if m != nil { + return m.TestOneof + } + return nil +} + +func (m *AllTypesOneOf) GetField1() float64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *AllTypesOneOf) GetField2() float32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *AllTypesOneOf) GetField3() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *AllTypesOneOf) GetField4() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field4); ok { + return x.Field4 + } + return 0 +} + +func (m *AllTypesOneOf) GetField5() uint32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field5); ok { + return x.Field5 + } + return 0 +} + +func (m *AllTypesOneOf) GetField6() uint64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field6); ok { + return x.Field6 + } + return 0 +} + +func (m *AllTypesOneOf) GetField7() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field7); ok { + return x.Field7 + } + return 0 +} + +func (m *AllTypesOneOf) GetField8() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field8); ok { + return x.Field8 + } + return 0 +} + +func (m *AllTypesOneOf) GetField9() uint32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field9); ok { + return x.Field9 + } + return 0 +} + +func (m *AllTypesOneOf) GetField10() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field10); ok { + return x.Field10 + } + return 0 +} + +func (m *AllTypesOneOf) GetField11() uint64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field11); ok { + return x.Field11 + } + return 0 +} + +func (m *AllTypesOneOf) GetField12() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field12); ok { + return x.Field12 + } + return 0 +} + +func (m *AllTypesOneOf) GetField13() bool { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field13); ok { + return x.Field13 + } + return false +} + +func (m *AllTypesOneOf) GetField14() string { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field14); ok { + return x.Field14 + } + return "" +} + +func (m *AllTypesOneOf) GetField15() []byte { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field15); ok { + return x.Field15 + } + return nil +} + +func (m *AllTypesOneOf) GetSubMessage() *Subby { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_SubMessage); ok { + return x.SubMessage + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*AllTypesOneOf) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _AllTypesOneOf_OneofMarshaler, _AllTypesOneOf_OneofUnmarshaler, []interface{}{ + (*AllTypesOneOf_Field1)(nil), + (*AllTypesOneOf_Field2)(nil), + (*AllTypesOneOf_Field3)(nil), + (*AllTypesOneOf_Field4)(nil), + (*AllTypesOneOf_Field5)(nil), + (*AllTypesOneOf_Field6)(nil), + (*AllTypesOneOf_Field7)(nil), + (*AllTypesOneOf_Field8)(nil), + (*AllTypesOneOf_Field9)(nil), + (*AllTypesOneOf_Field10)(nil), + (*AllTypesOneOf_Field11)(nil), + (*AllTypesOneOf_Field12)(nil), + (*AllTypesOneOf_Field13)(nil), + (*AllTypesOneOf_Field14)(nil), + (*AllTypesOneOf_Field15)(nil), + (*AllTypesOneOf_SubMessage)(nil), + } +} + +func _AllTypesOneOf_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*AllTypesOneOf) + // test_oneof + switch x := m.TestOneof.(type) { + case *AllTypesOneOf_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *AllTypesOneOf_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *AllTypesOneOf_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case *AllTypesOneOf_Field4: + _ = b.EncodeVarint(4<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field4)) + case *AllTypesOneOf_Field5: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field5)) + case *AllTypesOneOf_Field6: + _ = b.EncodeVarint(6<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field6)) + case *AllTypesOneOf_Field7: + _ = b.EncodeVarint(7<<3 | proto.WireVarint) + _ = b.EncodeZigzag32(uint64(x.Field7)) + case *AllTypesOneOf_Field8: + _ = b.EncodeVarint(8<<3 | proto.WireVarint) + _ = b.EncodeZigzag64(uint64(x.Field8)) + case *AllTypesOneOf_Field9: + _ = b.EncodeVarint(9<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field9)) + case *AllTypesOneOf_Field10: + _ = b.EncodeVarint(10<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field10)) + case *AllTypesOneOf_Field11: + _ = b.EncodeVarint(11<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field11)) + case *AllTypesOneOf_Field12: + _ = b.EncodeVarint(12<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field12)) + case *AllTypesOneOf_Field13: + t := uint64(0) + if x.Field13 { + t = 1 + } + _ = b.EncodeVarint(13<<3 | proto.WireVarint) + _ = b.EncodeVarint(t) + case *AllTypesOneOf_Field14: + _ = b.EncodeVarint(14<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field14) + case *AllTypesOneOf_Field15: + _ = b.EncodeVarint(15<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field15) + case *AllTypesOneOf_SubMessage: + _ = b.EncodeVarint(16<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("AllTypesOneOf.TestOneof has unexpected type %T", x) + } + return nil +} + +func _AllTypesOneOf_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*AllTypesOneOf) + switch tag { + case 1: // test_oneof.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field1{math.Float64frombits(x)} + return true, err + case 2: // test_oneof.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // test_oneof.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field3{int32(x)} + return true, err + case 4: // test_oneof.Field4 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field4{int64(x)} + return true, err + case 5: // test_oneof.Field5 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field5{uint32(x)} + return true, err + case 6: // test_oneof.Field6 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field6{x} + return true, err + case 7: // test_oneof.Field7 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag32() + m.TestOneof = &AllTypesOneOf_Field7{int32(x)} + return true, err + case 8: // test_oneof.Field8 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag64() + m.TestOneof = &AllTypesOneOf_Field8{int64(x)} + return true, err + case 9: // test_oneof.Field9 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field9{uint32(x)} + return true, err + case 10: // test_oneof.Field10 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field10{int32(x)} + return true, err + case 11: // test_oneof.Field11 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field11{x} + return true, err + case 12: // test_oneof.Field12 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field12{int64(x)} + return true, err + case 13: // test_oneof.Field13 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field13{x != 0} + return true, err + case 14: // test_oneof.Field14 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.TestOneof = &AllTypesOneOf_Field14{x} + return true, err + case 15: // test_oneof.Field15 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.TestOneof = &AllTypesOneOf_Field15{x} + return true, err + case 16: // test_oneof.sub_message + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.TestOneof = &AllTypesOneOf_SubMessage{msg} + return true, err + default: + return false, nil + } +} + +type TwoOneofs struct { + // Types that are valid to be assigned to One: + // *TwoOneofs_Field1 + // *TwoOneofs_Field2 + // *TwoOneofs_Field3 + One isTwoOneofs_One `protobuf_oneof:"one"` + // Types that are valid to be assigned to Two: + // *TwoOneofs_Field34 + // *TwoOneofs_Field35 + // *TwoOneofs_SubMessage2 + Two isTwoOneofs_Two `protobuf_oneof:"two"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TwoOneofs) Reset() { *m = TwoOneofs{} } +func (*TwoOneofs) ProtoMessage() {} + +type isTwoOneofs_One interface { + isTwoOneofs_One() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} +type isTwoOneofs_Two interface { + isTwoOneofs_Two() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} + +type TwoOneofs_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,oneof"` +} +type TwoOneofs_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,oneof"` +} +type TwoOneofs_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,oneof"` +} +type TwoOneofs_Field34 struct { + Field34 string `protobuf:"bytes,34,opt,name=Field34,oneof"` +} +type TwoOneofs_Field35 struct { + Field35 []byte `protobuf:"bytes,35,opt,name=Field35,oneof"` +} +type TwoOneofs_SubMessage2 struct { + SubMessage2 *Subby `protobuf:"bytes,36,opt,name=sub_message2,oneof"` +} + +func (*TwoOneofs_Field1) isTwoOneofs_One() {} +func (*TwoOneofs_Field2) isTwoOneofs_One() {} +func (*TwoOneofs_Field3) isTwoOneofs_One() {} +func (*TwoOneofs_Field34) isTwoOneofs_Two() {} +func (*TwoOneofs_Field35) isTwoOneofs_Two() {} +func (*TwoOneofs_SubMessage2) isTwoOneofs_Two() {} + +func (m *TwoOneofs) GetOne() isTwoOneofs_One { + if m != nil { + return m.One + } + return nil +} +func (m *TwoOneofs) GetTwo() isTwoOneofs_Two { + if m != nil { + return m.Two + } + return nil +} + +func (m *TwoOneofs) GetField1() float64 { + if x, ok := m.GetOne().(*TwoOneofs_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *TwoOneofs) GetField2() float32 { + if x, ok := m.GetOne().(*TwoOneofs_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *TwoOneofs) GetField3() int32 { + if x, ok := m.GetOne().(*TwoOneofs_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *TwoOneofs) GetField34() string { + if x, ok := m.GetTwo().(*TwoOneofs_Field34); ok { + return x.Field34 + } + return "" +} + +func (m *TwoOneofs) GetField35() []byte { + if x, ok := m.GetTwo().(*TwoOneofs_Field35); ok { + return x.Field35 + } + return nil +} + +func (m *TwoOneofs) GetSubMessage2() *Subby { + if x, ok := m.GetTwo().(*TwoOneofs_SubMessage2); ok { + return x.SubMessage2 + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*TwoOneofs) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _TwoOneofs_OneofMarshaler, _TwoOneofs_OneofUnmarshaler, []interface{}{ + (*TwoOneofs_Field1)(nil), + (*TwoOneofs_Field2)(nil), + (*TwoOneofs_Field3)(nil), + (*TwoOneofs_Field34)(nil), + (*TwoOneofs_Field35)(nil), + (*TwoOneofs_SubMessage2)(nil), + } +} + +func _TwoOneofs_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*TwoOneofs) + // one + switch x := m.One.(type) { + case *TwoOneofs_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *TwoOneofs_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *TwoOneofs_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case nil: + default: + return fmt.Errorf("TwoOneofs.One has unexpected type %T", x) + } + // two + switch x := m.Two.(type) { + case *TwoOneofs_Field34: + _ = b.EncodeVarint(34<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field34) + case *TwoOneofs_Field35: + _ = b.EncodeVarint(35<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field35) + case *TwoOneofs_SubMessage2: + _ = b.EncodeVarint(36<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage2); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("TwoOneofs.Two has unexpected type %T", x) + } + return nil +} + +func _TwoOneofs_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*TwoOneofs) + switch tag { + case 1: // one.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.One = &TwoOneofs_Field1{math.Float64frombits(x)} + return true, err + case 2: // one.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.One = &TwoOneofs_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // one.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.One = &TwoOneofs_Field3{int32(x)} + return true, err + case 34: // two.Field34 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Two = &TwoOneofs_Field34{x} + return true, err + case 35: // two.Field35 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.Two = &TwoOneofs_Field35{x} + return true, err + case 36: // two.sub_message2 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.Two = &TwoOneofs_SubMessage2{msg} + return true, err + default: + return false, nil + } +} + +type CustomOneof struct { + // Types that are valid to be assigned to Custom: + // *CustomOneof_Stringy + // *CustomOneof_CustomType + // *CustomOneof_CastType + // *CustomOneof_MyCustomName + Custom isCustomOneof_Custom `protobuf_oneof:"custom"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomOneof) Reset() { *m = CustomOneof{} } +func (*CustomOneof) ProtoMessage() {} + +type isCustomOneof_Custom interface { + isCustomOneof_Custom() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} + +type CustomOneof_Stringy struct { + Stringy string `protobuf:"bytes,34,opt,name=Stringy,oneof"` +} +type CustomOneof_CustomType struct { + CustomType github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,35,opt,name=CustomType,oneof,customtype=github.com/gogo/protobuf/test/custom.Uint128"` +} +type CustomOneof_CastType struct { + CastType github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,36,opt,name=CastType,oneof,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type"` +} +type CustomOneof_MyCustomName struct { + MyCustomName int64 `protobuf:"varint,37,opt,name=CustomName,oneof"` +} + +func (*CustomOneof_Stringy) isCustomOneof_Custom() {} +func (*CustomOneof_CustomType) isCustomOneof_Custom() {} +func (*CustomOneof_CastType) isCustomOneof_Custom() {} +func (*CustomOneof_MyCustomName) isCustomOneof_Custom() {} + +func (m *CustomOneof) GetCustom() isCustomOneof_Custom { + if m != nil { + return m.Custom + } + return nil +} + +func (m *CustomOneof) GetStringy() string { + if x, ok := m.GetCustom().(*CustomOneof_Stringy); ok { + return x.Stringy + } + return "" +} + +func (m *CustomOneof) GetCastType() github_com_gogo_protobuf_test_casttype.MyUint64Type { + if x, ok := m.GetCustom().(*CustomOneof_CastType); ok { + return x.CastType + } + return 0 +} + +func (m *CustomOneof) GetMyCustomName() int64 { + if x, ok := m.GetCustom().(*CustomOneof_MyCustomName); ok { + return x.MyCustomName + } + return 0 +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*CustomOneof) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _CustomOneof_OneofMarshaler, _CustomOneof_OneofUnmarshaler, []interface{}{ + (*CustomOneof_Stringy)(nil), + (*CustomOneof_CustomType)(nil), + (*CustomOneof_CastType)(nil), + (*CustomOneof_MyCustomName)(nil), + } +} + +func _CustomOneof_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*CustomOneof) + // custom + switch x := m.Custom.(type) { + case *CustomOneof_Stringy: + _ = b.EncodeVarint(34<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Stringy) + case *CustomOneof_CustomType: + _ = b.EncodeVarint(35<<3 | proto.WireBytes) + data, err := x.CustomType.Marshal() + if err != nil { + return err + } + _ = b.EncodeRawBytes(data) + case *CustomOneof_CastType: + _ = b.EncodeVarint(36<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.CastType)) + case *CustomOneof_MyCustomName: + _ = b.EncodeVarint(37<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.MyCustomName)) + case nil: + default: + return fmt.Errorf("CustomOneof.Custom has unexpected type %T", x) + } + return nil +} + +func _CustomOneof_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*CustomOneof) + switch tag { + case 34: // custom.Stringy + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Custom = &CustomOneof_Stringy{x} + return true, err + case 35: // custom.CustomType + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + if err != nil { + return true, err + } + var cc github_com_gogo_protobuf_test_custom.Uint128 + c := &cc + err = c.Unmarshal(x) + m.Custom = &CustomOneof_CustomType{*c} + return true, err + case 36: // custom.CastType + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Custom = &CustomOneof_CastType{github_com_gogo_protobuf_test_casttype.MyUint64Type(x)} + return true, err + case 37: // custom.CustomName + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Custom = &CustomOneof_MyCustomName{int64(x)} + return true, err + default: + return false, nil + } +} + +func (this *Subby) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *AllTypesOneOf) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *TwoOneofs) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *CustomOneof) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func OneDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/marshaler/one.proto"), + Package: func(v string) *string { return &v }("one"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Subby"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("sub"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("AllTypesOneOf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("sub_message"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(0), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("test_oneof")}}, + }, {Name: func(v string) *string { return &v }("TwoOneofs"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field34"), + Number: func(v int32) *int32 { return &v }(34), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("Field35"), + Number: func(v int32) *int32 { return &v }(35), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("sub_message2"), + Number: func(v int32) *int32 { return &v }(36), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(1), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("one")}, {Name: func(v string) *string { return &v }("two")}}, + }, {Name: func(v string) *string { return &v }("CustomOneof"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Stringy"), + Number: func(v int32) *int32 { return &v }(34), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CustomType"), + Number: func(v int32) *int32 { return &v }(35), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }, {Name: func(v string) *string { return &v }("CastType"), + Number: func(v int32) *int32 { return &v }(36), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("CustomName"), + Number: func(v int32) *int32 { return &v }(37), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0xc, 0x4d, 0x79, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4e, 0x61, 0x6d, 0x65})}}, + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("custom")}}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (this *Subby) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Subby) + if !ok { + return fmt.Errorf("that is not of type *Subby") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Subby but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Subbybut is not nil && this == nil") + } + if this.Sub != nil && that1.Sub != nil { + if *this.Sub != *that1.Sub { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", *this.Sub, *that1.Sub) + } + } else if this.Sub != nil { + return fmt.Errorf("this.Sub == nil && that.Sub != nil") + } else if that1.Sub != nil { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Subby) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Subby) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Sub != nil && that1.Sub != nil { + if *this.Sub != *that1.Sub { + return false + } + } else if this.Sub != nil { + return false + } else if that1.Sub != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllTypesOneOf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOfbut is not nil && this == nil") + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return fmt.Errorf("this.TestOneof != nil && that1.TestOneof == nil") + } + } else if this.TestOneof == nil { + return fmt.Errorf("this.TestOneof == nil && that1.TestOneof != nil") + } else if err := this.TestOneof.VerboseEqual(that1.TestOneof); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AllTypesOneOf_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field1) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *AllTypesOneOf_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field2) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *AllTypesOneOf_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field3) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *AllTypesOneOf_Field4) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field4) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field4") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field4 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field4but is not nil && this == nil") + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + return nil +} +func (this *AllTypesOneOf_Field5) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field5) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field5") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field5 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field5but is not nil && this == nil") + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + return nil +} +func (this *AllTypesOneOf_Field6) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field6) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field6") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field6 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field6but is not nil && this == nil") + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + return nil +} +func (this *AllTypesOneOf_Field7) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field7) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field7") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field7 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field7but is not nil && this == nil") + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + return nil +} +func (this *AllTypesOneOf_Field8) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field8) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field8") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field8 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field8but is not nil && this == nil") + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + return nil +} +func (this *AllTypesOneOf_Field9) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field9) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field9") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field9 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field9but is not nil && this == nil") + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + return nil +} +func (this *AllTypesOneOf_Field10) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field10) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field10") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field10 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field10but is not nil && this == nil") + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + return nil +} +func (this *AllTypesOneOf_Field11) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field11) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field11") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field11 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field11but is not nil && this == nil") + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + return nil +} +func (this *AllTypesOneOf_Field12) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field12) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field12") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field12 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field12but is not nil && this == nil") + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + return nil +} +func (this *AllTypesOneOf_Field13) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field13) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field13") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field13 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field13but is not nil && this == nil") + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + return nil +} +func (this *AllTypesOneOf_Field14) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field14) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field14") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field14 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field14but is not nil && this == nil") + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + return nil +} +func (this *AllTypesOneOf_Field15) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field15) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field15") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field15 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field15but is not nil && this == nil") + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + return nil +} +func (this *AllTypesOneOf_SubMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_SubMessage) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_SubMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_SubMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_SubMessagebut is not nil && this == nil") + } + if !this.SubMessage.Equal(that1.SubMessage) { + return fmt.Errorf("SubMessage this(%v) Not Equal that(%v)", this.SubMessage, that1.SubMessage) + } + return nil +} +func (this *AllTypesOneOf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return false + } + } else if this.TestOneof == nil { + return false + } else if !this.TestOneof.Equal(that1.TestOneof) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllTypesOneOf_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *AllTypesOneOf_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *AllTypesOneOf_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *AllTypesOneOf_Field4) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field4) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field4 != that1.Field4 { + return false + } + return true +} +func (this *AllTypesOneOf_Field5) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field5) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field5 != that1.Field5 { + return false + } + return true +} +func (this *AllTypesOneOf_Field6) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field6) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field6 != that1.Field6 { + return false + } + return true +} +func (this *AllTypesOneOf_Field7) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field7) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field7 != that1.Field7 { + return false + } + return true +} +func (this *AllTypesOneOf_Field8) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field8) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field8 != that1.Field8 { + return false + } + return true +} +func (this *AllTypesOneOf_Field9) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field9) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field9 != that1.Field9 { + return false + } + return true +} +func (this *AllTypesOneOf_Field10) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field10) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field10 != that1.Field10 { + return false + } + return true +} +func (this *AllTypesOneOf_Field11) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field11) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field11 != that1.Field11 { + return false + } + return true +} +func (this *AllTypesOneOf_Field12) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field12) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field12 != that1.Field12 { + return false + } + return true +} +func (this *AllTypesOneOf_Field13) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field13) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field13 != that1.Field13 { + return false + } + return true +} +func (this *AllTypesOneOf_Field14) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field14) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field14 != that1.Field14 { + return false + } + return true +} +func (this *AllTypesOneOf_Field15) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field15) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + return true +} +func (this *AllTypesOneOf_SubMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_SubMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage.Equal(that1.SubMessage) { + return false + } + return true +} +func (this *TwoOneofs) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofsbut is not nil && this == nil") + } + if that1.One == nil { + if this.One != nil { + return fmt.Errorf("this.One != nil && that1.One == nil") + } + } else if this.One == nil { + return fmt.Errorf("this.One == nil && that1.One != nil") + } else if err := this.One.VerboseEqual(that1.One); err != nil { + return err + } + if that1.Two == nil { + if this.Two != nil { + return fmt.Errorf("this.Two != nil && that1.Two == nil") + } + } else if this.Two == nil { + return fmt.Errorf("this.Two == nil && that1.Two != nil") + } else if err := this.Two.VerboseEqual(that1.Two); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *TwoOneofs_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field1) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *TwoOneofs_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field2) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *TwoOneofs_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field3) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *TwoOneofs_Field34) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field34) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field34") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field34 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field34but is not nil && this == nil") + } + if this.Field34 != that1.Field34 { + return fmt.Errorf("Field34 this(%v) Not Equal that(%v)", this.Field34, that1.Field34) + } + return nil +} +func (this *TwoOneofs_Field35) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field35) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field35") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field35 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field35but is not nil && this == nil") + } + if !bytes.Equal(this.Field35, that1.Field35) { + return fmt.Errorf("Field35 this(%v) Not Equal that(%v)", this.Field35, that1.Field35) + } + return nil +} +func (this *TwoOneofs_SubMessage2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_SubMessage2) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_SubMessage2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_SubMessage2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_SubMessage2but is not nil && this == nil") + } + if !this.SubMessage2.Equal(that1.SubMessage2) { + return fmt.Errorf("SubMessage2 this(%v) Not Equal that(%v)", this.SubMessage2, that1.SubMessage2) + } + return nil +} +func (this *TwoOneofs) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.One == nil { + if this.One != nil { + return false + } + } else if this.One == nil { + return false + } else if !this.One.Equal(that1.One) { + return false + } + if that1.Two == nil { + if this.Two != nil { + return false + } + } else if this.Two == nil { + return false + } else if !this.Two.Equal(that1.Two) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *TwoOneofs_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *TwoOneofs_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *TwoOneofs_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *TwoOneofs_Field34) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field34) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field34 != that1.Field34 { + return false + } + return true +} +func (this *TwoOneofs_Field35) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field35) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field35, that1.Field35) { + return false + } + return true +} +func (this *TwoOneofs_SubMessage2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_SubMessage2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage2.Equal(that1.SubMessage2) { + return false + } + return true +} +func (this *CustomOneof) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneofbut is not nil && this == nil") + } + if that1.Custom == nil { + if this.Custom != nil { + return fmt.Errorf("this.Custom != nil && that1.Custom == nil") + } + } else if this.Custom == nil { + return fmt.Errorf("this.Custom == nil && that1.Custom != nil") + } else if err := this.Custom.VerboseEqual(that1.Custom); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomOneof_Stringy) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_Stringy) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_Stringy") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_Stringy but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_Stringybut is not nil && this == nil") + } + if this.Stringy != that1.Stringy { + return fmt.Errorf("Stringy this(%v) Not Equal that(%v)", this.Stringy, that1.Stringy) + } + return nil +} +func (this *CustomOneof_CustomType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_CustomType) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_CustomType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_CustomType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_CustomTypebut is not nil && this == nil") + } + if !this.CustomType.Equal(that1.CustomType) { + return fmt.Errorf("CustomType this(%v) Not Equal that(%v)", this.CustomType, that1.CustomType) + } + return nil +} +func (this *CustomOneof_CastType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_CastType) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_CastType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_CastType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_CastTypebut is not nil && this == nil") + } + if this.CastType != that1.CastType { + return fmt.Errorf("CastType this(%v) Not Equal that(%v)", this.CastType, that1.CastType) + } + return nil +} +func (this *CustomOneof_MyCustomName) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_MyCustomName) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_MyCustomName") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_MyCustomName but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_MyCustomNamebut is not nil && this == nil") + } + if this.MyCustomName != that1.MyCustomName { + return fmt.Errorf("MyCustomName this(%v) Not Equal that(%v)", this.MyCustomName, that1.MyCustomName) + } + return nil +} +func (this *CustomOneof) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Custom == nil { + if this.Custom != nil { + return false + } + } else if this.Custom == nil { + return false + } else if !this.Custom.Equal(that1.Custom) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomOneof_Stringy) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_Stringy) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Stringy != that1.Stringy { + return false + } + return true +} +func (this *CustomOneof_CustomType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_CustomType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.CustomType.Equal(that1.CustomType) { + return false + } + return true +} +func (this *CustomOneof_CastType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_CastType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.CastType != that1.CastType { + return false + } + return true +} +func (this *CustomOneof_MyCustomName) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_MyCustomName) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.MyCustomName != that1.MyCustomName { + return false + } + return true +} +func (this *Subby) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&one.Subby{") + if this.Sub != nil { + s = append(s, "Sub: "+valueToGoStringOne(this.Sub, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllTypesOneOf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 20) + s = append(s, "&one.AllTypesOneOf{") + if this.TestOneof != nil { + s = append(s, "TestOneof: "+fmt.Sprintf("%#v", this.TestOneof)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllTypesOneOf_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field4) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field4{` + + `Field4:` + fmt.Sprintf("%#v", this.Field4) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field5) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field5{` + + `Field5:` + fmt.Sprintf("%#v", this.Field5) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field6) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field6{` + + `Field6:` + fmt.Sprintf("%#v", this.Field6) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field7) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field7{` + + `Field7:` + fmt.Sprintf("%#v", this.Field7) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field8) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field8{` + + `Field8:` + fmt.Sprintf("%#v", this.Field8) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field9) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field9{` + + `Field9:` + fmt.Sprintf("%#v", this.Field9) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field10) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field10{` + + `Field10:` + fmt.Sprintf("%#v", this.Field10) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field11) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field11{` + + `Field11:` + fmt.Sprintf("%#v", this.Field11) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field12) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field12{` + + `Field12:` + fmt.Sprintf("%#v", this.Field12) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field13) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field13{` + + `Field13:` + fmt.Sprintf("%#v", this.Field13) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field14) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field14{` + + `Field14:` + fmt.Sprintf("%#v", this.Field14) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field15) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field15{` + + `Field15:` + fmt.Sprintf("%#v", this.Field15) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_SubMessage) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_SubMessage{` + + `SubMessage:` + fmt.Sprintf("%#v", this.SubMessage) + `}`}, ", ") + return s +} +func (this *TwoOneofs) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 10) + s = append(s, "&one.TwoOneofs{") + if this.One != nil { + s = append(s, "One: "+fmt.Sprintf("%#v", this.One)+",\n") + } + if this.Two != nil { + s = append(s, "Two: "+fmt.Sprintf("%#v", this.Two)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *TwoOneofs_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field34) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field34{` + + `Field34:` + fmt.Sprintf("%#v", this.Field34) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field35) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field35{` + + `Field35:` + fmt.Sprintf("%#v", this.Field35) + `}`}, ", ") + return s +} +func (this *TwoOneofs_SubMessage2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_SubMessage2{` + + `SubMessage2:` + fmt.Sprintf("%#v", this.SubMessage2) + `}`}, ", ") + return s +} +func (this *CustomOneof) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&one.CustomOneof{") + if this.Custom != nil { + s = append(s, "Custom: "+fmt.Sprintf("%#v", this.Custom)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomOneof_Stringy) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_Stringy{` + + `Stringy:` + fmt.Sprintf("%#v", this.Stringy) + `}`}, ", ") + return s +} +func (this *CustomOneof_CustomType) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_CustomType{` + + `CustomType:` + fmt.Sprintf("%#v", this.CustomType) + `}`}, ", ") + return s +} +func (this *CustomOneof_CastType) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_CastType{` + + `CastType:` + fmt.Sprintf("%#v", this.CastType) + `}`}, ", ") + return s +} +func (this *CustomOneof_MyCustomName) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_MyCustomName{` + + `MyCustomName:` + fmt.Sprintf("%#v", this.MyCustomName) + `}`}, ", ") + return s +} +func valueToGoStringOne(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringOne(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *Subby) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Subby) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Sub != nil { + data[i] = 0xa + i++ + i = encodeVarintOne(data, i, uint64(len(*m.Sub))) + i += copy(data[i:], *m.Sub) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AllTypesOneOf) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AllTypesOneOf) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.TestOneof != nil { + nn1, err := m.TestOneof.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn1 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AllTypesOneOf_Field1) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x9 + i++ + i = encodeFixed64One(data, i, uint64(math.Float64bits(m.Field1))) + return i, nil +} +func (m *AllTypesOneOf_Field2) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x15 + i++ + i = encodeFixed32One(data, i, uint32(math.Float32bits(m.Field2))) + return i, nil +} +func (m *AllTypesOneOf_Field3) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x18 + i++ + i = encodeVarintOne(data, i, uint64(m.Field3)) + return i, nil +} +func (m *AllTypesOneOf_Field4) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x20 + i++ + i = encodeVarintOne(data, i, uint64(m.Field4)) + return i, nil +} +func (m *AllTypesOneOf_Field5) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x28 + i++ + i = encodeVarintOne(data, i, uint64(m.Field5)) + return i, nil +} +func (m *AllTypesOneOf_Field6) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x30 + i++ + i = encodeVarintOne(data, i, uint64(m.Field6)) + return i, nil +} +func (m *AllTypesOneOf_Field7) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x38 + i++ + i = encodeVarintOne(data, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31)))) + return i, nil +} +func (m *AllTypesOneOf_Field8) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x40 + i++ + i = encodeVarintOne(data, i, uint64((uint64(m.Field8)<<1)^uint64((m.Field8>>63)))) + return i, nil +} +func (m *AllTypesOneOf_Field9) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x4d + i++ + i = encodeFixed32One(data, i, uint32(m.Field9)) + return i, nil +} +func (m *AllTypesOneOf_Field10) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x55 + i++ + i = encodeFixed32One(data, i, uint32(m.Field10)) + return i, nil +} +func (m *AllTypesOneOf_Field11) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x59 + i++ + i = encodeFixed64One(data, i, uint64(m.Field11)) + return i, nil +} +func (m *AllTypesOneOf_Field12) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x61 + i++ + i = encodeFixed64One(data, i, uint64(m.Field12)) + return i, nil +} +func (m *AllTypesOneOf_Field13) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x68 + i++ + if m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + return i, nil +} +func (m *AllTypesOneOf_Field14) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x72 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field14))) + i += copy(data[i:], m.Field14) + return i, nil +} +func (m *AllTypesOneOf_Field15) MarshalTo(data []byte) (int, error) { + i := 0 + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + return i, nil +} +func (m *AllTypesOneOf_SubMessage) MarshalTo(data []byte) (int, error) { + i := 0 + if m.SubMessage != nil { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + i = encodeVarintOne(data, i, uint64(m.SubMessage.Size())) + n2, err := m.SubMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + } + return i, nil +} +func (m *TwoOneofs) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *TwoOneofs) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.One != nil { + nn3, err := m.One.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn3 + } + if m.Two != nil { + nn4, err := m.Two.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn4 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TwoOneofs_Field1) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x9 + i++ + i = encodeFixed64One(data, i, uint64(math.Float64bits(m.Field1))) + return i, nil +} +func (m *TwoOneofs_Field2) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x15 + i++ + i = encodeFixed32One(data, i, uint32(math.Float32bits(m.Field2))) + return i, nil +} +func (m *TwoOneofs_Field3) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x18 + i++ + i = encodeVarintOne(data, i, uint64(m.Field3)) + return i, nil +} +func (m *TwoOneofs_Field34) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x92 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field34))) + i += copy(data[i:], m.Field34) + return i, nil +} +func (m *TwoOneofs_Field35) MarshalTo(data []byte) (int, error) { + i := 0 + if m.Field35 != nil { + data[i] = 0x9a + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field35))) + i += copy(data[i:], m.Field35) + } + return i, nil +} +func (m *TwoOneofs_SubMessage2) MarshalTo(data []byte) (int, error) { + i := 0 + if m.SubMessage2 != nil { + data[i] = 0xa2 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(m.SubMessage2.Size())) + n5, err := m.SubMessage2.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n5 + } + return i, nil +} +func (m *CustomOneof) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomOneof) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Custom != nil { + nn6, err := m.Custom.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn6 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomOneof_Stringy) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x92 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Stringy))) + i += copy(data[i:], m.Stringy) + return i, nil +} +func (m *CustomOneof_CustomType) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x9a + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(m.CustomType.Size())) + n7, err := m.CustomType.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n7 + return i, nil +} +func (m *CustomOneof_CastType) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0xa0 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(m.CastType)) + return i, nil +} +func (m *CustomOneof_MyCustomName) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0xa8 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(m.MyCustomName)) + return i, nil +} +func encodeFixed64One(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32One(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintOne(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedSubby(r randyOne, easy bool) *Subby { + this := &Subby{} + if r.Intn(10) != 0 { + v1 := randStringOne(r) + this.Sub = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 2) + } + return this +} + +func NewPopulatedAllTypesOneOf(r randyOne, easy bool) *AllTypesOneOf { + this := &AllTypesOneOf{} + oneofNumber_TestOneof := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}[r.Intn(16)] + switch oneofNumber_TestOneof { + case 1: + this.TestOneof = NewPopulatedAllTypesOneOf_Field1(r, easy) + case 2: + this.TestOneof = NewPopulatedAllTypesOneOf_Field2(r, easy) + case 3: + this.TestOneof = NewPopulatedAllTypesOneOf_Field3(r, easy) + case 4: + this.TestOneof = NewPopulatedAllTypesOneOf_Field4(r, easy) + case 5: + this.TestOneof = NewPopulatedAllTypesOneOf_Field5(r, easy) + case 6: + this.TestOneof = NewPopulatedAllTypesOneOf_Field6(r, easy) + case 7: + this.TestOneof = NewPopulatedAllTypesOneOf_Field7(r, easy) + case 8: + this.TestOneof = NewPopulatedAllTypesOneOf_Field8(r, easy) + case 9: + this.TestOneof = NewPopulatedAllTypesOneOf_Field9(r, easy) + case 10: + this.TestOneof = NewPopulatedAllTypesOneOf_Field10(r, easy) + case 11: + this.TestOneof = NewPopulatedAllTypesOneOf_Field11(r, easy) + case 12: + this.TestOneof = NewPopulatedAllTypesOneOf_Field12(r, easy) + case 13: + this.TestOneof = NewPopulatedAllTypesOneOf_Field13(r, easy) + case 14: + this.TestOneof = NewPopulatedAllTypesOneOf_Field14(r, easy) + case 15: + this.TestOneof = NewPopulatedAllTypesOneOf_Field15(r, easy) + case 16: + this.TestOneof = NewPopulatedAllTypesOneOf_SubMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 17) + } + return this +} + +func NewPopulatedAllTypesOneOf_Field1(r randyOne, easy bool) *AllTypesOneOf_Field1 { + this := &AllTypesOneOf_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field2(r randyOne, easy bool) *AllTypesOneOf_Field2 { + this := &AllTypesOneOf_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field3(r randyOne, easy bool) *AllTypesOneOf_Field3 { + this := &AllTypesOneOf_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field4(r randyOne, easy bool) *AllTypesOneOf_Field4 { + this := &AllTypesOneOf_Field4{} + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field5(r randyOne, easy bool) *AllTypesOneOf_Field5 { + this := &AllTypesOneOf_Field5{} + this.Field5 = uint32(r.Uint32()) + return this +} +func NewPopulatedAllTypesOneOf_Field6(r randyOne, easy bool) *AllTypesOneOf_Field6 { + this := &AllTypesOneOf_Field6{} + this.Field6 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedAllTypesOneOf_Field7(r randyOne, easy bool) *AllTypesOneOf_Field7 { + this := &AllTypesOneOf_Field7{} + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field8(r randyOne, easy bool) *AllTypesOneOf_Field8 { + this := &AllTypesOneOf_Field8{} + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field9(r randyOne, easy bool) *AllTypesOneOf_Field9 { + this := &AllTypesOneOf_Field9{} + this.Field9 = uint32(r.Uint32()) + return this +} +func NewPopulatedAllTypesOneOf_Field10(r randyOne, easy bool) *AllTypesOneOf_Field10 { + this := &AllTypesOneOf_Field10{} + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field11(r randyOne, easy bool) *AllTypesOneOf_Field11 { + this := &AllTypesOneOf_Field11{} + this.Field11 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedAllTypesOneOf_Field12(r randyOne, easy bool) *AllTypesOneOf_Field12 { + this := &AllTypesOneOf_Field12{} + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field13(r randyOne, easy bool) *AllTypesOneOf_Field13 { + this := &AllTypesOneOf_Field13{} + this.Field13 = bool(bool(r.Intn(2) == 0)) + return this +} +func NewPopulatedAllTypesOneOf_Field14(r randyOne, easy bool) *AllTypesOneOf_Field14 { + this := &AllTypesOneOf_Field14{} + this.Field14 = randStringOne(r) + return this +} +func NewPopulatedAllTypesOneOf_Field15(r randyOne, easy bool) *AllTypesOneOf_Field15 { + this := &AllTypesOneOf_Field15{} + v2 := r.Intn(100) + this.Field15 = make([]byte, v2) + for i := 0; i < v2; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedAllTypesOneOf_SubMessage(r randyOne, easy bool) *AllTypesOneOf_SubMessage { + this := &AllTypesOneOf_SubMessage{} + this.SubMessage = NewPopulatedSubby(r, easy) + return this +} +func NewPopulatedTwoOneofs(r randyOne, easy bool) *TwoOneofs { + this := &TwoOneofs{} + oneofNumber_One := []int32{1, 2, 3}[r.Intn(3)] + switch oneofNumber_One { + case 1: + this.One = NewPopulatedTwoOneofs_Field1(r, easy) + case 2: + this.One = NewPopulatedTwoOneofs_Field2(r, easy) + case 3: + this.One = NewPopulatedTwoOneofs_Field3(r, easy) + } + oneofNumber_Two := []int32{34, 35, 36}[r.Intn(3)] + switch oneofNumber_Two { + case 34: + this.Two = NewPopulatedTwoOneofs_Field34(r, easy) + case 35: + this.Two = NewPopulatedTwoOneofs_Field35(r, easy) + case 36: + this.Two = NewPopulatedTwoOneofs_SubMessage2(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 37) + } + return this +} + +func NewPopulatedTwoOneofs_Field1(r randyOne, easy bool) *TwoOneofs_Field1 { + this := &TwoOneofs_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field2(r randyOne, easy bool) *TwoOneofs_Field2 { + this := &TwoOneofs_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field3(r randyOne, easy bool) *TwoOneofs_Field3 { + this := &TwoOneofs_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field34(r randyOne, easy bool) *TwoOneofs_Field34 { + this := &TwoOneofs_Field34{} + this.Field34 = randStringOne(r) + return this +} +func NewPopulatedTwoOneofs_Field35(r randyOne, easy bool) *TwoOneofs_Field35 { + this := &TwoOneofs_Field35{} + v3 := r.Intn(100) + this.Field35 = make([]byte, v3) + for i := 0; i < v3; i++ { + this.Field35[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedTwoOneofs_SubMessage2(r randyOne, easy bool) *TwoOneofs_SubMessage2 { + this := &TwoOneofs_SubMessage2{} + this.SubMessage2 = NewPopulatedSubby(r, easy) + return this +} +func NewPopulatedCustomOneof(r randyOne, easy bool) *CustomOneof { + this := &CustomOneof{} + oneofNumber_Custom := []int32{34, 35, 36, 37}[r.Intn(4)] + switch oneofNumber_Custom { + case 34: + this.Custom = NewPopulatedCustomOneof_Stringy(r, easy) + case 35: + this.Custom = NewPopulatedCustomOneof_CustomType(r, easy) + case 36: + this.Custom = NewPopulatedCustomOneof_CastType(r, easy) + case 37: + this.Custom = NewPopulatedCustomOneof_MyCustomName(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 38) + } + return this +} + +func NewPopulatedCustomOneof_Stringy(r randyOne, easy bool) *CustomOneof_Stringy { + this := &CustomOneof_Stringy{} + this.Stringy = randStringOne(r) + return this +} +func NewPopulatedCustomOneof_CustomType(r randyOne, easy bool) *CustomOneof_CustomType { + this := &CustomOneof_CustomType{} + v4 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.CustomType = *v4 + return this +} +func NewPopulatedCustomOneof_CastType(r randyOne, easy bool) *CustomOneof_CastType { + this := &CustomOneof_CastType{} + this.CastType = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + return this +} +func NewPopulatedCustomOneof_MyCustomName(r randyOne, easy bool) *CustomOneof_MyCustomName { + this := &CustomOneof_MyCustomName{} + this.MyCustomName = int64(r.Int63()) + if r.Intn(2) == 0 { + this.MyCustomName *= -1 + } + return this +} + +type randyOne interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneOne(r randyOne) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringOne(r randyOne) string { + v5 := r.Intn(100) + tmps := make([]rune, v5) + for i := 0; i < v5; i++ { + tmps[i] = randUTF8RuneOne(r) + } + return string(tmps) +} +func randUnrecognizedOne(r randyOne, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldOne(data, r, fieldNumber, wire) + } + return data +} +func randFieldOne(data []byte, r randyOne, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateOne(data, uint64(key)) + v6 := r.Int63() + if r.Intn(2) == 0 { + v6 *= -1 + } + data = encodeVarintPopulateOne(data, uint64(v6)) + case 1: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateOne(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateOne(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateOne(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Subby) Size() (n int) { + var l int + _ = l + if m.Sub != nil { + l = len(*m.Sub) + n += 1 + l + sovOne(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllTypesOneOf) Size() (n int) { + var l int + _ = l + if m.TestOneof != nil { + n += m.TestOneof.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllTypesOneOf_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *AllTypesOneOf_Field4) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field4)) + return n +} +func (m *AllTypesOneOf_Field5) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field5)) + return n +} +func (m *AllTypesOneOf_Field6) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field6)) + return n +} +func (m *AllTypesOneOf_Field7) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field7)) + return n +} +func (m *AllTypesOneOf_Field8) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field8)) + return n +} +func (m *AllTypesOneOf_Field9) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field10) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field11) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field12) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field13) Size() (n int) { + var l int + _ = l + n += 2 + return n +} +func (m *AllTypesOneOf_Field14) Size() (n int) { + var l int + _ = l + l = len(m.Field14) + n += 1 + l + sovOne(uint64(l)) + return n +} +func (m *AllTypesOneOf_Field15) Size() (n int) { + var l int + _ = l + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovOne(uint64(l)) + } + return n +} +func (m *AllTypesOneOf_SubMessage) Size() (n int) { + var l int + _ = l + if m.SubMessage != nil { + l = m.SubMessage.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *TwoOneofs) Size() (n int) { + var l int + _ = l + if m.One != nil { + n += m.One.Size() + } + if m.Two != nil { + n += m.Two.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TwoOneofs_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *TwoOneofs_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *TwoOneofs_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *TwoOneofs_Field34) Size() (n int) { + var l int + _ = l + l = len(m.Field34) + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *TwoOneofs_Field35) Size() (n int) { + var l int + _ = l + if m.Field35 != nil { + l = len(m.Field35) + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *TwoOneofs_SubMessage2) Size() (n int) { + var l int + _ = l + if m.SubMessage2 != nil { + l = m.SubMessage2.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *CustomOneof) Size() (n int) { + var l int + _ = l + if m.Custom != nil { + n += m.Custom.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomOneof_Stringy) Size() (n int) { + var l int + _ = l + l = len(m.Stringy) + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *CustomOneof_CustomType) Size() (n int) { + var l int + _ = l + l = m.CustomType.Size() + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *CustomOneof_CastType) Size() (n int) { + var l int + _ = l + n += 2 + sovOne(uint64(m.CastType)) + return n +} +func (m *CustomOneof_MyCustomName) Size() (n int) { + var l int + _ = l + n += 2 + sovOne(uint64(m.MyCustomName)) + return n +} + +func sovOne(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozOne(x uint64) (n int) { + return sovOne(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Subby) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Subby{`, + `Sub:` + valueToStringOne(this.Sub) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf{`, + `TestOneof:` + fmt.Sprintf("%v", this.TestOneof) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field4) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field4{`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field5) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field5{`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field6) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field6{`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field7) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field7{`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field8) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field8{`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field9) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field9{`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field10) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field10{`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field11) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field11{`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field12) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field12{`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field13) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field13{`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field14) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field14{`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field15) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field15{`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_SubMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_SubMessage{`, + `SubMessage:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs{`, + `One:` + fmt.Sprintf("%v", this.One) + `,`, + `Two:` + fmt.Sprintf("%v", this.Two) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field34) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field34{`, + `Field34:` + fmt.Sprintf("%v", this.Field34) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field35) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field35{`, + `Field35:` + fmt.Sprintf("%v", this.Field35) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_SubMessage2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_SubMessage2{`, + `SubMessage2:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage2), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof{`, + `Custom:` + fmt.Sprintf("%v", this.Custom) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_Stringy) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_Stringy{`, + `Stringy:` + fmt.Sprintf("%v", this.Stringy) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_CustomType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_CustomType{`, + `CustomType:` + fmt.Sprintf("%v", this.CustomType) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_CastType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_CastType{`, + `CastType:` + fmt.Sprintf("%v", this.CastType) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_MyCustomName) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_MyCustomName{`, + `MyCustomName:` + fmt.Sprintf("%v", this.MyCustomName) + `,`, + `}`, + }, "") + return s +} +func valueToStringOne(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/marshaler/one.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/marshaler/one.proto new file mode 100644 index 0000000000000000000000000000000000000000..30e171ade2b6b161bdc59a31e74c79f01a97c297 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/marshaler/one.proto @@ -0,0 +1,101 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package one; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Subby { + optional string sub = 1; +} + +message AllTypesOneOf { + oneof test_oneof { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + int64 Field4 = 4; + uint32 Field5 = 5; + uint64 Field6 = 6; + sint32 Field7 = 7; + sint64 Field8 = 8; + fixed32 Field9 = 9; + sfixed32 Field10 = 10; + fixed64 Field11 = 11; + sfixed64 Field12 = 12; + bool Field13 = 13; + string Field14 = 14; + bytes Field15 = 15; + Subby sub_message = 16; + } +} + +message TwoOneofs { + oneof one { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + } + + oneof two { + string Field34 = 34; + bytes Field35 = 35; + Subby sub_message2 = 36; + } +} + +message CustomOneof { + oneof custom { + string Stringy = 34; + bytes CustomType = 35 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; + uint64 CastType = 36 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + int64 CustomName = 37 [(gogoproto.customname) = "MyCustomName"]; + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/marshaler/onepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/marshaler/onepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..4fdd79c0653528b781c79b5e53d6bcb552988e49 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/marshaler/onepb_test.go @@ -0,0 +1,744 @@ +// Code generated by protoc-gen-gogo. +// source: combos/marshaler/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/marshaler/one.proto + +It has these top-level messages: + Subby + AllTypesOneOf + TwoOneofs + CustomOneof +*/ +package one + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestSubbyProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSubbyMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAllTypesOneOfMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestTwoOneofsMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomOneofMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllTypesOneOfJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTwoOneofsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomOneofJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSubbyProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOneDescription(t *testing.T) { + OneDescription() +} +func TestSubbyVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllTypesOneOfVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTwoOneofsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomOneofVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSubbyGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllTypesOneOfGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTwoOneofsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomOneofGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSubbySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestAllTypesOneOfSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestTwoOneofsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestCustomOneofSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSubbyStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllTypesOneOfStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTwoOneofsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomOneofStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/neither/one.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/neither/one.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..08364b78bbdce8f74a57917f384058a256817bb0 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/neither/one.pb.go @@ -0,0 +1,5332 @@ +// Code generated by protoc-gen-gogo. +// source: combos/neither/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/neither/one.proto + +It has these top-level messages: + Subby + AllTypesOneOf + TwoOneofs + CustomOneof +*/ +package one + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_custom "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom" +import github_com_gogo_protobuf_test_casttype "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Subby struct { + Sub *string `protobuf:"bytes,1,opt,name=sub" json:"sub,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Subby) Reset() { *m = Subby{} } +func (*Subby) ProtoMessage() {} + +type AllTypesOneOf struct { + // Types that are valid to be assigned to TestOneof: + // *AllTypesOneOf_Field1 + // *AllTypesOneOf_Field2 + // *AllTypesOneOf_Field3 + // *AllTypesOneOf_Field4 + // *AllTypesOneOf_Field5 + // *AllTypesOneOf_Field6 + // *AllTypesOneOf_Field7 + // *AllTypesOneOf_Field8 + // *AllTypesOneOf_Field9 + // *AllTypesOneOf_Field10 + // *AllTypesOneOf_Field11 + // *AllTypesOneOf_Field12 + // *AllTypesOneOf_Field13 + // *AllTypesOneOf_Field14 + // *AllTypesOneOf_Field15 + // *AllTypesOneOf_SubMessage + TestOneof isAllTypesOneOf_TestOneof `protobuf_oneof:"test_oneof"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllTypesOneOf) Reset() { *m = AllTypesOneOf{} } +func (*AllTypesOneOf) ProtoMessage() {} + +type isAllTypesOneOf_TestOneof interface { + isAllTypesOneOf_TestOneof() + Equal(interface{}) bool + VerboseEqual(interface{}) error + Size() int +} + +type AllTypesOneOf_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,oneof"` +} +type AllTypesOneOf_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,oneof"` +} +type AllTypesOneOf_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,oneof"` +} +type AllTypesOneOf_Field4 struct { + Field4 int64 `protobuf:"varint,4,opt,name=Field4,oneof"` +} +type AllTypesOneOf_Field5 struct { + Field5 uint32 `protobuf:"varint,5,opt,name=Field5,oneof"` +} +type AllTypesOneOf_Field6 struct { + Field6 uint64 `protobuf:"varint,6,opt,name=Field6,oneof"` +} +type AllTypesOneOf_Field7 struct { + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7,oneof"` +} +type AllTypesOneOf_Field8 struct { + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8,oneof"` +} +type AllTypesOneOf_Field9 struct { + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9,oneof"` +} +type AllTypesOneOf_Field10 struct { + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10,oneof"` +} +type AllTypesOneOf_Field11 struct { + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11,oneof"` +} +type AllTypesOneOf_Field12 struct { + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12,oneof"` +} +type AllTypesOneOf_Field13 struct { + Field13 bool `protobuf:"varint,13,opt,name=Field13,oneof"` +} +type AllTypesOneOf_Field14 struct { + Field14 string `protobuf:"bytes,14,opt,name=Field14,oneof"` +} +type AllTypesOneOf_Field15 struct { + Field15 []byte `protobuf:"bytes,15,opt,name=Field15,oneof"` +} +type AllTypesOneOf_SubMessage struct { + SubMessage *Subby `protobuf:"bytes,16,opt,name=sub_message,oneof"` +} + +func (*AllTypesOneOf_Field1) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field2) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field3) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field4) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field5) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field6) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field7) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field8) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field9) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field10) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field11) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field12) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field13) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field14) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field15) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_SubMessage) isAllTypesOneOf_TestOneof() {} + +func (m *AllTypesOneOf) GetTestOneof() isAllTypesOneOf_TestOneof { + if m != nil { + return m.TestOneof + } + return nil +} + +func (m *AllTypesOneOf) GetField1() float64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *AllTypesOneOf) GetField2() float32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *AllTypesOneOf) GetField3() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *AllTypesOneOf) GetField4() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field4); ok { + return x.Field4 + } + return 0 +} + +func (m *AllTypesOneOf) GetField5() uint32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field5); ok { + return x.Field5 + } + return 0 +} + +func (m *AllTypesOneOf) GetField6() uint64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field6); ok { + return x.Field6 + } + return 0 +} + +func (m *AllTypesOneOf) GetField7() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field7); ok { + return x.Field7 + } + return 0 +} + +func (m *AllTypesOneOf) GetField8() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field8); ok { + return x.Field8 + } + return 0 +} + +func (m *AllTypesOneOf) GetField9() uint32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field9); ok { + return x.Field9 + } + return 0 +} + +func (m *AllTypesOneOf) GetField10() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field10); ok { + return x.Field10 + } + return 0 +} + +func (m *AllTypesOneOf) GetField11() uint64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field11); ok { + return x.Field11 + } + return 0 +} + +func (m *AllTypesOneOf) GetField12() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field12); ok { + return x.Field12 + } + return 0 +} + +func (m *AllTypesOneOf) GetField13() bool { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field13); ok { + return x.Field13 + } + return false +} + +func (m *AllTypesOneOf) GetField14() string { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field14); ok { + return x.Field14 + } + return "" +} + +func (m *AllTypesOneOf) GetField15() []byte { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field15); ok { + return x.Field15 + } + return nil +} + +func (m *AllTypesOneOf) GetSubMessage() *Subby { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_SubMessage); ok { + return x.SubMessage + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*AllTypesOneOf) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _AllTypesOneOf_OneofMarshaler, _AllTypesOneOf_OneofUnmarshaler, []interface{}{ + (*AllTypesOneOf_Field1)(nil), + (*AllTypesOneOf_Field2)(nil), + (*AllTypesOneOf_Field3)(nil), + (*AllTypesOneOf_Field4)(nil), + (*AllTypesOneOf_Field5)(nil), + (*AllTypesOneOf_Field6)(nil), + (*AllTypesOneOf_Field7)(nil), + (*AllTypesOneOf_Field8)(nil), + (*AllTypesOneOf_Field9)(nil), + (*AllTypesOneOf_Field10)(nil), + (*AllTypesOneOf_Field11)(nil), + (*AllTypesOneOf_Field12)(nil), + (*AllTypesOneOf_Field13)(nil), + (*AllTypesOneOf_Field14)(nil), + (*AllTypesOneOf_Field15)(nil), + (*AllTypesOneOf_SubMessage)(nil), + } +} + +func _AllTypesOneOf_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*AllTypesOneOf) + // test_oneof + switch x := m.TestOneof.(type) { + case *AllTypesOneOf_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *AllTypesOneOf_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *AllTypesOneOf_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case *AllTypesOneOf_Field4: + _ = b.EncodeVarint(4<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field4)) + case *AllTypesOneOf_Field5: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field5)) + case *AllTypesOneOf_Field6: + _ = b.EncodeVarint(6<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field6)) + case *AllTypesOneOf_Field7: + _ = b.EncodeVarint(7<<3 | proto.WireVarint) + _ = b.EncodeZigzag32(uint64(x.Field7)) + case *AllTypesOneOf_Field8: + _ = b.EncodeVarint(8<<3 | proto.WireVarint) + _ = b.EncodeZigzag64(uint64(x.Field8)) + case *AllTypesOneOf_Field9: + _ = b.EncodeVarint(9<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field9)) + case *AllTypesOneOf_Field10: + _ = b.EncodeVarint(10<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field10)) + case *AllTypesOneOf_Field11: + _ = b.EncodeVarint(11<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field11)) + case *AllTypesOneOf_Field12: + _ = b.EncodeVarint(12<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field12)) + case *AllTypesOneOf_Field13: + t := uint64(0) + if x.Field13 { + t = 1 + } + _ = b.EncodeVarint(13<<3 | proto.WireVarint) + _ = b.EncodeVarint(t) + case *AllTypesOneOf_Field14: + _ = b.EncodeVarint(14<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field14) + case *AllTypesOneOf_Field15: + _ = b.EncodeVarint(15<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field15) + case *AllTypesOneOf_SubMessage: + _ = b.EncodeVarint(16<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("AllTypesOneOf.TestOneof has unexpected type %T", x) + } + return nil +} + +func _AllTypesOneOf_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*AllTypesOneOf) + switch tag { + case 1: // test_oneof.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field1{math.Float64frombits(x)} + return true, err + case 2: // test_oneof.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // test_oneof.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field3{int32(x)} + return true, err + case 4: // test_oneof.Field4 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field4{int64(x)} + return true, err + case 5: // test_oneof.Field5 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field5{uint32(x)} + return true, err + case 6: // test_oneof.Field6 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field6{x} + return true, err + case 7: // test_oneof.Field7 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag32() + m.TestOneof = &AllTypesOneOf_Field7{int32(x)} + return true, err + case 8: // test_oneof.Field8 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag64() + m.TestOneof = &AllTypesOneOf_Field8{int64(x)} + return true, err + case 9: // test_oneof.Field9 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field9{uint32(x)} + return true, err + case 10: // test_oneof.Field10 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field10{int32(x)} + return true, err + case 11: // test_oneof.Field11 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field11{x} + return true, err + case 12: // test_oneof.Field12 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field12{int64(x)} + return true, err + case 13: // test_oneof.Field13 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field13{x != 0} + return true, err + case 14: // test_oneof.Field14 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.TestOneof = &AllTypesOneOf_Field14{x} + return true, err + case 15: // test_oneof.Field15 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.TestOneof = &AllTypesOneOf_Field15{x} + return true, err + case 16: // test_oneof.sub_message + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.TestOneof = &AllTypesOneOf_SubMessage{msg} + return true, err + default: + return false, nil + } +} + +type TwoOneofs struct { + // Types that are valid to be assigned to One: + // *TwoOneofs_Field1 + // *TwoOneofs_Field2 + // *TwoOneofs_Field3 + One isTwoOneofs_One `protobuf_oneof:"one"` + // Types that are valid to be assigned to Two: + // *TwoOneofs_Field34 + // *TwoOneofs_Field35 + // *TwoOneofs_SubMessage2 + Two isTwoOneofs_Two `protobuf_oneof:"two"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TwoOneofs) Reset() { *m = TwoOneofs{} } +func (*TwoOneofs) ProtoMessage() {} + +type isTwoOneofs_One interface { + isTwoOneofs_One() + Equal(interface{}) bool + VerboseEqual(interface{}) error + Size() int +} +type isTwoOneofs_Two interface { + isTwoOneofs_Two() + Equal(interface{}) bool + VerboseEqual(interface{}) error + Size() int +} + +type TwoOneofs_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,oneof"` +} +type TwoOneofs_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,oneof"` +} +type TwoOneofs_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,oneof"` +} +type TwoOneofs_Field34 struct { + Field34 string `protobuf:"bytes,34,opt,name=Field34,oneof"` +} +type TwoOneofs_Field35 struct { + Field35 []byte `protobuf:"bytes,35,opt,name=Field35,oneof"` +} +type TwoOneofs_SubMessage2 struct { + SubMessage2 *Subby `protobuf:"bytes,36,opt,name=sub_message2,oneof"` +} + +func (*TwoOneofs_Field1) isTwoOneofs_One() {} +func (*TwoOneofs_Field2) isTwoOneofs_One() {} +func (*TwoOneofs_Field3) isTwoOneofs_One() {} +func (*TwoOneofs_Field34) isTwoOneofs_Two() {} +func (*TwoOneofs_Field35) isTwoOneofs_Two() {} +func (*TwoOneofs_SubMessage2) isTwoOneofs_Two() {} + +func (m *TwoOneofs) GetOne() isTwoOneofs_One { + if m != nil { + return m.One + } + return nil +} +func (m *TwoOneofs) GetTwo() isTwoOneofs_Two { + if m != nil { + return m.Two + } + return nil +} + +func (m *TwoOneofs) GetField1() float64 { + if x, ok := m.GetOne().(*TwoOneofs_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *TwoOneofs) GetField2() float32 { + if x, ok := m.GetOne().(*TwoOneofs_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *TwoOneofs) GetField3() int32 { + if x, ok := m.GetOne().(*TwoOneofs_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *TwoOneofs) GetField34() string { + if x, ok := m.GetTwo().(*TwoOneofs_Field34); ok { + return x.Field34 + } + return "" +} + +func (m *TwoOneofs) GetField35() []byte { + if x, ok := m.GetTwo().(*TwoOneofs_Field35); ok { + return x.Field35 + } + return nil +} + +func (m *TwoOneofs) GetSubMessage2() *Subby { + if x, ok := m.GetTwo().(*TwoOneofs_SubMessage2); ok { + return x.SubMessage2 + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*TwoOneofs) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _TwoOneofs_OneofMarshaler, _TwoOneofs_OneofUnmarshaler, []interface{}{ + (*TwoOneofs_Field1)(nil), + (*TwoOneofs_Field2)(nil), + (*TwoOneofs_Field3)(nil), + (*TwoOneofs_Field34)(nil), + (*TwoOneofs_Field35)(nil), + (*TwoOneofs_SubMessage2)(nil), + } +} + +func _TwoOneofs_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*TwoOneofs) + // one + switch x := m.One.(type) { + case *TwoOneofs_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *TwoOneofs_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *TwoOneofs_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case nil: + default: + return fmt.Errorf("TwoOneofs.One has unexpected type %T", x) + } + // two + switch x := m.Two.(type) { + case *TwoOneofs_Field34: + _ = b.EncodeVarint(34<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field34) + case *TwoOneofs_Field35: + _ = b.EncodeVarint(35<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field35) + case *TwoOneofs_SubMessage2: + _ = b.EncodeVarint(36<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage2); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("TwoOneofs.Two has unexpected type %T", x) + } + return nil +} + +func _TwoOneofs_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*TwoOneofs) + switch tag { + case 1: // one.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.One = &TwoOneofs_Field1{math.Float64frombits(x)} + return true, err + case 2: // one.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.One = &TwoOneofs_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // one.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.One = &TwoOneofs_Field3{int32(x)} + return true, err + case 34: // two.Field34 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Two = &TwoOneofs_Field34{x} + return true, err + case 35: // two.Field35 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.Two = &TwoOneofs_Field35{x} + return true, err + case 36: // two.sub_message2 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.Two = &TwoOneofs_SubMessage2{msg} + return true, err + default: + return false, nil + } +} + +type CustomOneof struct { + // Types that are valid to be assigned to Custom: + // *CustomOneof_Stringy + // *CustomOneof_CustomType + // *CustomOneof_CastType + // *CustomOneof_MyCustomName + Custom isCustomOneof_Custom `protobuf_oneof:"custom"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomOneof) Reset() { *m = CustomOneof{} } +func (*CustomOneof) ProtoMessage() {} + +type isCustomOneof_Custom interface { + isCustomOneof_Custom() + Equal(interface{}) bool + VerboseEqual(interface{}) error + Size() int +} + +type CustomOneof_Stringy struct { + Stringy string `protobuf:"bytes,34,opt,name=Stringy,oneof"` +} +type CustomOneof_CustomType struct { + CustomType github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,35,opt,name=CustomType,oneof,customtype=github.com/gogo/protobuf/test/custom.Uint128"` +} +type CustomOneof_CastType struct { + CastType github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,36,opt,name=CastType,oneof,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type"` +} +type CustomOneof_MyCustomName struct { + MyCustomName int64 `protobuf:"varint,37,opt,name=CustomName,oneof"` +} + +func (*CustomOneof_Stringy) isCustomOneof_Custom() {} +func (*CustomOneof_CustomType) isCustomOneof_Custom() {} +func (*CustomOneof_CastType) isCustomOneof_Custom() {} +func (*CustomOneof_MyCustomName) isCustomOneof_Custom() {} + +func (m *CustomOneof) GetCustom() isCustomOneof_Custom { + if m != nil { + return m.Custom + } + return nil +} + +func (m *CustomOneof) GetStringy() string { + if x, ok := m.GetCustom().(*CustomOneof_Stringy); ok { + return x.Stringy + } + return "" +} + +func (m *CustomOneof) GetCastType() github_com_gogo_protobuf_test_casttype.MyUint64Type { + if x, ok := m.GetCustom().(*CustomOneof_CastType); ok { + return x.CastType + } + return 0 +} + +func (m *CustomOneof) GetMyCustomName() int64 { + if x, ok := m.GetCustom().(*CustomOneof_MyCustomName); ok { + return x.MyCustomName + } + return 0 +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*CustomOneof) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _CustomOneof_OneofMarshaler, _CustomOneof_OneofUnmarshaler, []interface{}{ + (*CustomOneof_Stringy)(nil), + (*CustomOneof_CustomType)(nil), + (*CustomOneof_CastType)(nil), + (*CustomOneof_MyCustomName)(nil), + } +} + +func _CustomOneof_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*CustomOneof) + // custom + switch x := m.Custom.(type) { + case *CustomOneof_Stringy: + _ = b.EncodeVarint(34<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Stringy) + case *CustomOneof_CustomType: + _ = b.EncodeVarint(35<<3 | proto.WireBytes) + data, err := x.CustomType.Marshal() + if err != nil { + return err + } + _ = b.EncodeRawBytes(data) + case *CustomOneof_CastType: + _ = b.EncodeVarint(36<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.CastType)) + case *CustomOneof_MyCustomName: + _ = b.EncodeVarint(37<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.MyCustomName)) + case nil: + default: + return fmt.Errorf("CustomOneof.Custom has unexpected type %T", x) + } + return nil +} + +func _CustomOneof_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*CustomOneof) + switch tag { + case 34: // custom.Stringy + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Custom = &CustomOneof_Stringy{x} + return true, err + case 35: // custom.CustomType + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + if err != nil { + return true, err + } + var cc github_com_gogo_protobuf_test_custom.Uint128 + c := &cc + err = c.Unmarshal(x) + m.Custom = &CustomOneof_CustomType{*c} + return true, err + case 36: // custom.CastType + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Custom = &CustomOneof_CastType{github_com_gogo_protobuf_test_casttype.MyUint64Type(x)} + return true, err + case 37: // custom.CustomName + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Custom = &CustomOneof_MyCustomName{int64(x)} + return true, err + default: + return false, nil + } +} + +func (this *Subby) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *AllTypesOneOf) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *TwoOneofs) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *CustomOneof) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func OneDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/neither/one.proto"), + Package: func(v string) *string { return &v }("one"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Subby"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("sub"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("AllTypesOneOf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("sub_message"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(0), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("test_oneof")}}, + }, {Name: func(v string) *string { return &v }("TwoOneofs"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field34"), + Number: func(v int32) *int32 { return &v }(34), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("Field35"), + Number: func(v int32) *int32 { return &v }(35), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("sub_message2"), + Number: func(v int32) *int32 { return &v }(36), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(1), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("one")}, {Name: func(v string) *string { return &v }("two")}}, + }, {Name: func(v string) *string { return &v }("CustomOneof"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Stringy"), + Number: func(v int32) *int32 { return &v }(34), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CustomType"), + Number: func(v int32) *int32 { return &v }(35), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }, {Name: func(v string) *string { return &v }("CastType"), + Number: func(v int32) *int32 { return &v }(36), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("CustomName"), + Number: func(v int32) *int32 { return &v }(37), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0xc, 0x4d, 0x79, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4e, 0x61, 0x6d, 0x65})}}, + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("custom")}}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (this *Subby) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Subby) + if !ok { + return fmt.Errorf("that is not of type *Subby") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Subby but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Subbybut is not nil && this == nil") + } + if this.Sub != nil && that1.Sub != nil { + if *this.Sub != *that1.Sub { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", *this.Sub, *that1.Sub) + } + } else if this.Sub != nil { + return fmt.Errorf("this.Sub == nil && that.Sub != nil") + } else if that1.Sub != nil { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Subby) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Subby) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Sub != nil && that1.Sub != nil { + if *this.Sub != *that1.Sub { + return false + } + } else if this.Sub != nil { + return false + } else if that1.Sub != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllTypesOneOf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOfbut is not nil && this == nil") + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return fmt.Errorf("this.TestOneof != nil && that1.TestOneof == nil") + } + } else if this.TestOneof == nil { + return fmt.Errorf("this.TestOneof == nil && that1.TestOneof != nil") + } else if err := this.TestOneof.VerboseEqual(that1.TestOneof); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AllTypesOneOf_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field1) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *AllTypesOneOf_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field2) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *AllTypesOneOf_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field3) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *AllTypesOneOf_Field4) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field4) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field4") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field4 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field4but is not nil && this == nil") + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + return nil +} +func (this *AllTypesOneOf_Field5) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field5) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field5") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field5 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field5but is not nil && this == nil") + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + return nil +} +func (this *AllTypesOneOf_Field6) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field6) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field6") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field6 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field6but is not nil && this == nil") + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + return nil +} +func (this *AllTypesOneOf_Field7) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field7) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field7") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field7 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field7but is not nil && this == nil") + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + return nil +} +func (this *AllTypesOneOf_Field8) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field8) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field8") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field8 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field8but is not nil && this == nil") + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + return nil +} +func (this *AllTypesOneOf_Field9) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field9) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field9") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field9 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field9but is not nil && this == nil") + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + return nil +} +func (this *AllTypesOneOf_Field10) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field10) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field10") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field10 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field10but is not nil && this == nil") + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + return nil +} +func (this *AllTypesOneOf_Field11) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field11) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field11") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field11 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field11but is not nil && this == nil") + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + return nil +} +func (this *AllTypesOneOf_Field12) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field12) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field12") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field12 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field12but is not nil && this == nil") + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + return nil +} +func (this *AllTypesOneOf_Field13) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field13) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field13") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field13 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field13but is not nil && this == nil") + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + return nil +} +func (this *AllTypesOneOf_Field14) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field14) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field14") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field14 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field14but is not nil && this == nil") + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + return nil +} +func (this *AllTypesOneOf_Field15) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field15) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field15") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field15 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field15but is not nil && this == nil") + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + return nil +} +func (this *AllTypesOneOf_SubMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_SubMessage) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_SubMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_SubMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_SubMessagebut is not nil && this == nil") + } + if !this.SubMessage.Equal(that1.SubMessage) { + return fmt.Errorf("SubMessage this(%v) Not Equal that(%v)", this.SubMessage, that1.SubMessage) + } + return nil +} +func (this *AllTypesOneOf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return false + } + } else if this.TestOneof == nil { + return false + } else if !this.TestOneof.Equal(that1.TestOneof) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllTypesOneOf_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *AllTypesOneOf_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *AllTypesOneOf_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *AllTypesOneOf_Field4) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field4) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field4 != that1.Field4 { + return false + } + return true +} +func (this *AllTypesOneOf_Field5) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field5) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field5 != that1.Field5 { + return false + } + return true +} +func (this *AllTypesOneOf_Field6) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field6) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field6 != that1.Field6 { + return false + } + return true +} +func (this *AllTypesOneOf_Field7) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field7) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field7 != that1.Field7 { + return false + } + return true +} +func (this *AllTypesOneOf_Field8) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field8) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field8 != that1.Field8 { + return false + } + return true +} +func (this *AllTypesOneOf_Field9) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field9) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field9 != that1.Field9 { + return false + } + return true +} +func (this *AllTypesOneOf_Field10) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field10) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field10 != that1.Field10 { + return false + } + return true +} +func (this *AllTypesOneOf_Field11) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field11) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field11 != that1.Field11 { + return false + } + return true +} +func (this *AllTypesOneOf_Field12) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field12) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field12 != that1.Field12 { + return false + } + return true +} +func (this *AllTypesOneOf_Field13) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field13) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field13 != that1.Field13 { + return false + } + return true +} +func (this *AllTypesOneOf_Field14) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field14) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field14 != that1.Field14 { + return false + } + return true +} +func (this *AllTypesOneOf_Field15) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field15) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + return true +} +func (this *AllTypesOneOf_SubMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_SubMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage.Equal(that1.SubMessage) { + return false + } + return true +} +func (this *TwoOneofs) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofsbut is not nil && this == nil") + } + if that1.One == nil { + if this.One != nil { + return fmt.Errorf("this.One != nil && that1.One == nil") + } + } else if this.One == nil { + return fmt.Errorf("this.One == nil && that1.One != nil") + } else if err := this.One.VerboseEqual(that1.One); err != nil { + return err + } + if that1.Two == nil { + if this.Two != nil { + return fmt.Errorf("this.Two != nil && that1.Two == nil") + } + } else if this.Two == nil { + return fmt.Errorf("this.Two == nil && that1.Two != nil") + } else if err := this.Two.VerboseEqual(that1.Two); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *TwoOneofs_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field1) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *TwoOneofs_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field2) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *TwoOneofs_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field3) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *TwoOneofs_Field34) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field34) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field34") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field34 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field34but is not nil && this == nil") + } + if this.Field34 != that1.Field34 { + return fmt.Errorf("Field34 this(%v) Not Equal that(%v)", this.Field34, that1.Field34) + } + return nil +} +func (this *TwoOneofs_Field35) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field35) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field35") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field35 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field35but is not nil && this == nil") + } + if !bytes.Equal(this.Field35, that1.Field35) { + return fmt.Errorf("Field35 this(%v) Not Equal that(%v)", this.Field35, that1.Field35) + } + return nil +} +func (this *TwoOneofs_SubMessage2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_SubMessage2) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_SubMessage2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_SubMessage2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_SubMessage2but is not nil && this == nil") + } + if !this.SubMessage2.Equal(that1.SubMessage2) { + return fmt.Errorf("SubMessage2 this(%v) Not Equal that(%v)", this.SubMessage2, that1.SubMessage2) + } + return nil +} +func (this *TwoOneofs) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.One == nil { + if this.One != nil { + return false + } + } else if this.One == nil { + return false + } else if !this.One.Equal(that1.One) { + return false + } + if that1.Two == nil { + if this.Two != nil { + return false + } + } else if this.Two == nil { + return false + } else if !this.Two.Equal(that1.Two) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *TwoOneofs_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *TwoOneofs_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *TwoOneofs_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *TwoOneofs_Field34) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field34) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field34 != that1.Field34 { + return false + } + return true +} +func (this *TwoOneofs_Field35) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field35) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field35, that1.Field35) { + return false + } + return true +} +func (this *TwoOneofs_SubMessage2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_SubMessage2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage2.Equal(that1.SubMessage2) { + return false + } + return true +} +func (this *CustomOneof) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneofbut is not nil && this == nil") + } + if that1.Custom == nil { + if this.Custom != nil { + return fmt.Errorf("this.Custom != nil && that1.Custom == nil") + } + } else if this.Custom == nil { + return fmt.Errorf("this.Custom == nil && that1.Custom != nil") + } else if err := this.Custom.VerboseEqual(that1.Custom); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomOneof_Stringy) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_Stringy) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_Stringy") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_Stringy but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_Stringybut is not nil && this == nil") + } + if this.Stringy != that1.Stringy { + return fmt.Errorf("Stringy this(%v) Not Equal that(%v)", this.Stringy, that1.Stringy) + } + return nil +} +func (this *CustomOneof_CustomType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_CustomType) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_CustomType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_CustomType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_CustomTypebut is not nil && this == nil") + } + if !this.CustomType.Equal(that1.CustomType) { + return fmt.Errorf("CustomType this(%v) Not Equal that(%v)", this.CustomType, that1.CustomType) + } + return nil +} +func (this *CustomOneof_CastType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_CastType) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_CastType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_CastType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_CastTypebut is not nil && this == nil") + } + if this.CastType != that1.CastType { + return fmt.Errorf("CastType this(%v) Not Equal that(%v)", this.CastType, that1.CastType) + } + return nil +} +func (this *CustomOneof_MyCustomName) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_MyCustomName) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_MyCustomName") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_MyCustomName but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_MyCustomNamebut is not nil && this == nil") + } + if this.MyCustomName != that1.MyCustomName { + return fmt.Errorf("MyCustomName this(%v) Not Equal that(%v)", this.MyCustomName, that1.MyCustomName) + } + return nil +} +func (this *CustomOneof) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Custom == nil { + if this.Custom != nil { + return false + } + } else if this.Custom == nil { + return false + } else if !this.Custom.Equal(that1.Custom) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomOneof_Stringy) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_Stringy) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Stringy != that1.Stringy { + return false + } + return true +} +func (this *CustomOneof_CustomType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_CustomType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.CustomType.Equal(that1.CustomType) { + return false + } + return true +} +func (this *CustomOneof_CastType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_CastType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.CastType != that1.CastType { + return false + } + return true +} +func (this *CustomOneof_MyCustomName) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_MyCustomName) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.MyCustomName != that1.MyCustomName { + return false + } + return true +} +func (this *Subby) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&one.Subby{") + if this.Sub != nil { + s = append(s, "Sub: "+valueToGoStringOne(this.Sub, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllTypesOneOf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 20) + s = append(s, "&one.AllTypesOneOf{") + if this.TestOneof != nil { + s = append(s, "TestOneof: "+fmt.Sprintf("%#v", this.TestOneof)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllTypesOneOf_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field4) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field4{` + + `Field4:` + fmt.Sprintf("%#v", this.Field4) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field5) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field5{` + + `Field5:` + fmt.Sprintf("%#v", this.Field5) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field6) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field6{` + + `Field6:` + fmt.Sprintf("%#v", this.Field6) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field7) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field7{` + + `Field7:` + fmt.Sprintf("%#v", this.Field7) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field8) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field8{` + + `Field8:` + fmt.Sprintf("%#v", this.Field8) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field9) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field9{` + + `Field9:` + fmt.Sprintf("%#v", this.Field9) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field10) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field10{` + + `Field10:` + fmt.Sprintf("%#v", this.Field10) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field11) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field11{` + + `Field11:` + fmt.Sprintf("%#v", this.Field11) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field12) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field12{` + + `Field12:` + fmt.Sprintf("%#v", this.Field12) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field13) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field13{` + + `Field13:` + fmt.Sprintf("%#v", this.Field13) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field14) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field14{` + + `Field14:` + fmt.Sprintf("%#v", this.Field14) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field15) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field15{` + + `Field15:` + fmt.Sprintf("%#v", this.Field15) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_SubMessage) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_SubMessage{` + + `SubMessage:` + fmt.Sprintf("%#v", this.SubMessage) + `}`}, ", ") + return s +} +func (this *TwoOneofs) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 10) + s = append(s, "&one.TwoOneofs{") + if this.One != nil { + s = append(s, "One: "+fmt.Sprintf("%#v", this.One)+",\n") + } + if this.Two != nil { + s = append(s, "Two: "+fmt.Sprintf("%#v", this.Two)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *TwoOneofs_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field34) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field34{` + + `Field34:` + fmt.Sprintf("%#v", this.Field34) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field35) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field35{` + + `Field35:` + fmt.Sprintf("%#v", this.Field35) + `}`}, ", ") + return s +} +func (this *TwoOneofs_SubMessage2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_SubMessage2{` + + `SubMessage2:` + fmt.Sprintf("%#v", this.SubMessage2) + `}`}, ", ") + return s +} +func (this *CustomOneof) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&one.CustomOneof{") + if this.Custom != nil { + s = append(s, "Custom: "+fmt.Sprintf("%#v", this.Custom)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomOneof_Stringy) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_Stringy{` + + `Stringy:` + fmt.Sprintf("%#v", this.Stringy) + `}`}, ", ") + return s +} +func (this *CustomOneof_CustomType) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_CustomType{` + + `CustomType:` + fmt.Sprintf("%#v", this.CustomType) + `}`}, ", ") + return s +} +func (this *CustomOneof_CastType) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_CastType{` + + `CastType:` + fmt.Sprintf("%#v", this.CastType) + `}`}, ", ") + return s +} +func (this *CustomOneof_MyCustomName) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_MyCustomName{` + + `MyCustomName:` + fmt.Sprintf("%#v", this.MyCustomName) + `}`}, ", ") + return s +} +func valueToGoStringOne(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringOne(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedSubby(r randyOne, easy bool) *Subby { + this := &Subby{} + if r.Intn(10) != 0 { + v1 := randStringOne(r) + this.Sub = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 2) + } + return this +} + +func NewPopulatedAllTypesOneOf(r randyOne, easy bool) *AllTypesOneOf { + this := &AllTypesOneOf{} + oneofNumber_TestOneof := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}[r.Intn(16)] + switch oneofNumber_TestOneof { + case 1: + this.TestOneof = NewPopulatedAllTypesOneOf_Field1(r, easy) + case 2: + this.TestOneof = NewPopulatedAllTypesOneOf_Field2(r, easy) + case 3: + this.TestOneof = NewPopulatedAllTypesOneOf_Field3(r, easy) + case 4: + this.TestOneof = NewPopulatedAllTypesOneOf_Field4(r, easy) + case 5: + this.TestOneof = NewPopulatedAllTypesOneOf_Field5(r, easy) + case 6: + this.TestOneof = NewPopulatedAllTypesOneOf_Field6(r, easy) + case 7: + this.TestOneof = NewPopulatedAllTypesOneOf_Field7(r, easy) + case 8: + this.TestOneof = NewPopulatedAllTypesOneOf_Field8(r, easy) + case 9: + this.TestOneof = NewPopulatedAllTypesOneOf_Field9(r, easy) + case 10: + this.TestOneof = NewPopulatedAllTypesOneOf_Field10(r, easy) + case 11: + this.TestOneof = NewPopulatedAllTypesOneOf_Field11(r, easy) + case 12: + this.TestOneof = NewPopulatedAllTypesOneOf_Field12(r, easy) + case 13: + this.TestOneof = NewPopulatedAllTypesOneOf_Field13(r, easy) + case 14: + this.TestOneof = NewPopulatedAllTypesOneOf_Field14(r, easy) + case 15: + this.TestOneof = NewPopulatedAllTypesOneOf_Field15(r, easy) + case 16: + this.TestOneof = NewPopulatedAllTypesOneOf_SubMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 17) + } + return this +} + +func NewPopulatedAllTypesOneOf_Field1(r randyOne, easy bool) *AllTypesOneOf_Field1 { + this := &AllTypesOneOf_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field2(r randyOne, easy bool) *AllTypesOneOf_Field2 { + this := &AllTypesOneOf_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field3(r randyOne, easy bool) *AllTypesOneOf_Field3 { + this := &AllTypesOneOf_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field4(r randyOne, easy bool) *AllTypesOneOf_Field4 { + this := &AllTypesOneOf_Field4{} + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field5(r randyOne, easy bool) *AllTypesOneOf_Field5 { + this := &AllTypesOneOf_Field5{} + this.Field5 = uint32(r.Uint32()) + return this +} +func NewPopulatedAllTypesOneOf_Field6(r randyOne, easy bool) *AllTypesOneOf_Field6 { + this := &AllTypesOneOf_Field6{} + this.Field6 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedAllTypesOneOf_Field7(r randyOne, easy bool) *AllTypesOneOf_Field7 { + this := &AllTypesOneOf_Field7{} + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field8(r randyOne, easy bool) *AllTypesOneOf_Field8 { + this := &AllTypesOneOf_Field8{} + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field9(r randyOne, easy bool) *AllTypesOneOf_Field9 { + this := &AllTypesOneOf_Field9{} + this.Field9 = uint32(r.Uint32()) + return this +} +func NewPopulatedAllTypesOneOf_Field10(r randyOne, easy bool) *AllTypesOneOf_Field10 { + this := &AllTypesOneOf_Field10{} + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field11(r randyOne, easy bool) *AllTypesOneOf_Field11 { + this := &AllTypesOneOf_Field11{} + this.Field11 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedAllTypesOneOf_Field12(r randyOne, easy bool) *AllTypesOneOf_Field12 { + this := &AllTypesOneOf_Field12{} + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field13(r randyOne, easy bool) *AllTypesOneOf_Field13 { + this := &AllTypesOneOf_Field13{} + this.Field13 = bool(bool(r.Intn(2) == 0)) + return this +} +func NewPopulatedAllTypesOneOf_Field14(r randyOne, easy bool) *AllTypesOneOf_Field14 { + this := &AllTypesOneOf_Field14{} + this.Field14 = randStringOne(r) + return this +} +func NewPopulatedAllTypesOneOf_Field15(r randyOne, easy bool) *AllTypesOneOf_Field15 { + this := &AllTypesOneOf_Field15{} + v2 := r.Intn(100) + this.Field15 = make([]byte, v2) + for i := 0; i < v2; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedAllTypesOneOf_SubMessage(r randyOne, easy bool) *AllTypesOneOf_SubMessage { + this := &AllTypesOneOf_SubMessage{} + this.SubMessage = NewPopulatedSubby(r, easy) + return this +} +func NewPopulatedTwoOneofs(r randyOne, easy bool) *TwoOneofs { + this := &TwoOneofs{} + oneofNumber_One := []int32{1, 2, 3}[r.Intn(3)] + switch oneofNumber_One { + case 1: + this.One = NewPopulatedTwoOneofs_Field1(r, easy) + case 2: + this.One = NewPopulatedTwoOneofs_Field2(r, easy) + case 3: + this.One = NewPopulatedTwoOneofs_Field3(r, easy) + } + oneofNumber_Two := []int32{34, 35, 36}[r.Intn(3)] + switch oneofNumber_Two { + case 34: + this.Two = NewPopulatedTwoOneofs_Field34(r, easy) + case 35: + this.Two = NewPopulatedTwoOneofs_Field35(r, easy) + case 36: + this.Two = NewPopulatedTwoOneofs_SubMessage2(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 37) + } + return this +} + +func NewPopulatedTwoOneofs_Field1(r randyOne, easy bool) *TwoOneofs_Field1 { + this := &TwoOneofs_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field2(r randyOne, easy bool) *TwoOneofs_Field2 { + this := &TwoOneofs_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field3(r randyOne, easy bool) *TwoOneofs_Field3 { + this := &TwoOneofs_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field34(r randyOne, easy bool) *TwoOneofs_Field34 { + this := &TwoOneofs_Field34{} + this.Field34 = randStringOne(r) + return this +} +func NewPopulatedTwoOneofs_Field35(r randyOne, easy bool) *TwoOneofs_Field35 { + this := &TwoOneofs_Field35{} + v3 := r.Intn(100) + this.Field35 = make([]byte, v3) + for i := 0; i < v3; i++ { + this.Field35[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedTwoOneofs_SubMessage2(r randyOne, easy bool) *TwoOneofs_SubMessage2 { + this := &TwoOneofs_SubMessage2{} + this.SubMessage2 = NewPopulatedSubby(r, easy) + return this +} +func NewPopulatedCustomOneof(r randyOne, easy bool) *CustomOneof { + this := &CustomOneof{} + oneofNumber_Custom := []int32{34, 35, 36, 37}[r.Intn(4)] + switch oneofNumber_Custom { + case 34: + this.Custom = NewPopulatedCustomOneof_Stringy(r, easy) + case 35: + this.Custom = NewPopulatedCustomOneof_CustomType(r, easy) + case 36: + this.Custom = NewPopulatedCustomOneof_CastType(r, easy) + case 37: + this.Custom = NewPopulatedCustomOneof_MyCustomName(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 38) + } + return this +} + +func NewPopulatedCustomOneof_Stringy(r randyOne, easy bool) *CustomOneof_Stringy { + this := &CustomOneof_Stringy{} + this.Stringy = randStringOne(r) + return this +} +func NewPopulatedCustomOneof_CustomType(r randyOne, easy bool) *CustomOneof_CustomType { + this := &CustomOneof_CustomType{} + v4 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.CustomType = *v4 + return this +} +func NewPopulatedCustomOneof_CastType(r randyOne, easy bool) *CustomOneof_CastType { + this := &CustomOneof_CastType{} + this.CastType = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + return this +} +func NewPopulatedCustomOneof_MyCustomName(r randyOne, easy bool) *CustomOneof_MyCustomName { + this := &CustomOneof_MyCustomName{} + this.MyCustomName = int64(r.Int63()) + if r.Intn(2) == 0 { + this.MyCustomName *= -1 + } + return this +} + +type randyOne interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneOne(r randyOne) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringOne(r randyOne) string { + v5 := r.Intn(100) + tmps := make([]rune, v5) + for i := 0; i < v5; i++ { + tmps[i] = randUTF8RuneOne(r) + } + return string(tmps) +} +func randUnrecognizedOne(r randyOne, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldOne(data, r, fieldNumber, wire) + } + return data +} +func randFieldOne(data []byte, r randyOne, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateOne(data, uint64(key)) + v6 := r.Int63() + if r.Intn(2) == 0 { + v6 *= -1 + } + data = encodeVarintPopulateOne(data, uint64(v6)) + case 1: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateOne(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateOne(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateOne(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Subby) Size() (n int) { + var l int + _ = l + if m.Sub != nil { + l = len(*m.Sub) + n += 1 + l + sovOne(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllTypesOneOf) Size() (n int) { + var l int + _ = l + if m.TestOneof != nil { + n += m.TestOneof.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllTypesOneOf_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *AllTypesOneOf_Field4) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field4)) + return n +} +func (m *AllTypesOneOf_Field5) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field5)) + return n +} +func (m *AllTypesOneOf_Field6) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field6)) + return n +} +func (m *AllTypesOneOf_Field7) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field7)) + return n +} +func (m *AllTypesOneOf_Field8) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field8)) + return n +} +func (m *AllTypesOneOf_Field9) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field10) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field11) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field12) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field13) Size() (n int) { + var l int + _ = l + n += 2 + return n +} +func (m *AllTypesOneOf_Field14) Size() (n int) { + var l int + _ = l + l = len(m.Field14) + n += 1 + l + sovOne(uint64(l)) + return n +} +func (m *AllTypesOneOf_Field15) Size() (n int) { + var l int + _ = l + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovOne(uint64(l)) + } + return n +} +func (m *AllTypesOneOf_SubMessage) Size() (n int) { + var l int + _ = l + if m.SubMessage != nil { + l = m.SubMessage.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *TwoOneofs) Size() (n int) { + var l int + _ = l + if m.One != nil { + n += m.One.Size() + } + if m.Two != nil { + n += m.Two.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TwoOneofs_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *TwoOneofs_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *TwoOneofs_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *TwoOneofs_Field34) Size() (n int) { + var l int + _ = l + l = len(m.Field34) + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *TwoOneofs_Field35) Size() (n int) { + var l int + _ = l + if m.Field35 != nil { + l = len(m.Field35) + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *TwoOneofs_SubMessage2) Size() (n int) { + var l int + _ = l + if m.SubMessage2 != nil { + l = m.SubMessage2.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *CustomOneof) Size() (n int) { + var l int + _ = l + if m.Custom != nil { + n += m.Custom.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomOneof_Stringy) Size() (n int) { + var l int + _ = l + l = len(m.Stringy) + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *CustomOneof_CustomType) Size() (n int) { + var l int + _ = l + l = m.CustomType.Size() + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *CustomOneof_CastType) Size() (n int) { + var l int + _ = l + n += 2 + sovOne(uint64(m.CastType)) + return n +} +func (m *CustomOneof_MyCustomName) Size() (n int) { + var l int + _ = l + n += 2 + sovOne(uint64(m.MyCustomName)) + return n +} + +func sovOne(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozOne(x uint64) (n int) { + return sovOne(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Subby) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Subby{`, + `Sub:` + valueToStringOne(this.Sub) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf{`, + `TestOneof:` + fmt.Sprintf("%v", this.TestOneof) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field4) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field4{`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field5) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field5{`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field6) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field6{`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field7) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field7{`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field8) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field8{`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field9) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field9{`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field10) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field10{`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field11) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field11{`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field12) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field12{`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field13) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field13{`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field14) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field14{`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field15) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field15{`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_SubMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_SubMessage{`, + `SubMessage:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs{`, + `One:` + fmt.Sprintf("%v", this.One) + `,`, + `Two:` + fmt.Sprintf("%v", this.Two) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field34) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field34{`, + `Field34:` + fmt.Sprintf("%v", this.Field34) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field35) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field35{`, + `Field35:` + fmt.Sprintf("%v", this.Field35) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_SubMessage2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_SubMessage2{`, + `SubMessage2:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage2), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof{`, + `Custom:` + fmt.Sprintf("%v", this.Custom) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_Stringy) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_Stringy{`, + `Stringy:` + fmt.Sprintf("%v", this.Stringy) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_CustomType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_CustomType{`, + `CustomType:` + fmt.Sprintf("%v", this.CustomType) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_CastType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_CastType{`, + `CastType:` + fmt.Sprintf("%v", this.CastType) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_MyCustomName) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_MyCustomName{`, + `MyCustomName:` + fmt.Sprintf("%v", this.MyCustomName) + `,`, + `}`, + }, "") + return s +} +func valueToStringOne(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/neither/one.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/neither/one.proto new file mode 100644 index 0000000000000000000000000000000000000000..0c88ac86a0dfd3c9e4bf2b28891e71487099b328 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/neither/one.proto @@ -0,0 +1,101 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package one; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Subby { + optional string sub = 1; +} + +message AllTypesOneOf { + oneof test_oneof { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + int64 Field4 = 4; + uint32 Field5 = 5; + uint64 Field6 = 6; + sint32 Field7 = 7; + sint64 Field8 = 8; + fixed32 Field9 = 9; + sfixed32 Field10 = 10; + fixed64 Field11 = 11; + sfixed64 Field12 = 12; + bool Field13 = 13; + string Field14 = 14; + bytes Field15 = 15; + Subby sub_message = 16; + } +} + +message TwoOneofs { + oneof one { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + } + + oneof two { + string Field34 = 34; + bytes Field35 = 35; + Subby sub_message2 = 36; + } +} + +message CustomOneof { + oneof custom { + string Stringy = 34; + bytes CustomType = 35 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; + uint64 CastType = 36 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + int64 CustomName = 37 [(gogoproto.customname) = "MyCustomName"]; + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/neither/onepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/neither/onepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..33bd6fb7e3c0600ef1a350e2287eddca4c00fb9b --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/neither/onepb_test.go @@ -0,0 +1,632 @@ +// Code generated by protoc-gen-gogo. +// source: combos/neither/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/neither/one.proto + +It has these top-level messages: + Subby + AllTypesOneOf + TwoOneofs + CustomOneof +*/ +package one + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestSubbyProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAllTypesOneOfProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestTwoOneofsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomOneofProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSubbyJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllTypesOneOfJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTwoOneofsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomOneofJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSubbyProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOneDescription(t *testing.T) { + OneDescription() +} +func TestSubbyVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllTypesOneOfVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTwoOneofsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomOneofVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSubbyGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllTypesOneOfGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTwoOneofsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomOneofGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSubbySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestAllTypesOneOfSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestTwoOneofsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestCustomOneofSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSubbyStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllTypesOneOfStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTwoOneofsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomOneofStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unmarshaler/one.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unmarshaler/one.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..02df09e063d40a1fa5f2e0356af500c7cc32f6ae --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unmarshaler/one.pb.go @@ -0,0 +1,6247 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unmarshaler/one.proto +// DO NOT EDIT! + +/* + Package one is a generated protocol buffer package. + + It is generated from these files: + combos/unmarshaler/one.proto + + It has these top-level messages: + Subby + AllTypesOneOf + TwoOneofs + CustomOneof +*/ +package one + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_custom "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom" +import github_com_gogo_protobuf_test_casttype "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Subby struct { + Sub *string `protobuf:"bytes,1,opt,name=sub" json:"sub,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Subby) Reset() { *m = Subby{} } +func (*Subby) ProtoMessage() {} + +type AllTypesOneOf struct { + // Types that are valid to be assigned to TestOneof: + // *AllTypesOneOf_Field1 + // *AllTypesOneOf_Field2 + // *AllTypesOneOf_Field3 + // *AllTypesOneOf_Field4 + // *AllTypesOneOf_Field5 + // *AllTypesOneOf_Field6 + // *AllTypesOneOf_Field7 + // *AllTypesOneOf_Field8 + // *AllTypesOneOf_Field9 + // *AllTypesOneOf_Field10 + // *AllTypesOneOf_Field11 + // *AllTypesOneOf_Field12 + // *AllTypesOneOf_Field13 + // *AllTypesOneOf_Field14 + // *AllTypesOneOf_Field15 + // *AllTypesOneOf_SubMessage + TestOneof isAllTypesOneOf_TestOneof `protobuf_oneof:"test_oneof"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllTypesOneOf) Reset() { *m = AllTypesOneOf{} } +func (*AllTypesOneOf) ProtoMessage() {} + +type isAllTypesOneOf_TestOneof interface { + isAllTypesOneOf_TestOneof() + Equal(interface{}) bool + VerboseEqual(interface{}) error + Size() int +} + +type AllTypesOneOf_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,oneof"` +} +type AllTypesOneOf_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,oneof"` +} +type AllTypesOneOf_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,oneof"` +} +type AllTypesOneOf_Field4 struct { + Field4 int64 `protobuf:"varint,4,opt,name=Field4,oneof"` +} +type AllTypesOneOf_Field5 struct { + Field5 uint32 `protobuf:"varint,5,opt,name=Field5,oneof"` +} +type AllTypesOneOf_Field6 struct { + Field6 uint64 `protobuf:"varint,6,opt,name=Field6,oneof"` +} +type AllTypesOneOf_Field7 struct { + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7,oneof"` +} +type AllTypesOneOf_Field8 struct { + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8,oneof"` +} +type AllTypesOneOf_Field9 struct { + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9,oneof"` +} +type AllTypesOneOf_Field10 struct { + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10,oneof"` +} +type AllTypesOneOf_Field11 struct { + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11,oneof"` +} +type AllTypesOneOf_Field12 struct { + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12,oneof"` +} +type AllTypesOneOf_Field13 struct { + Field13 bool `protobuf:"varint,13,opt,name=Field13,oneof"` +} +type AllTypesOneOf_Field14 struct { + Field14 string `protobuf:"bytes,14,opt,name=Field14,oneof"` +} +type AllTypesOneOf_Field15 struct { + Field15 []byte `protobuf:"bytes,15,opt,name=Field15,oneof"` +} +type AllTypesOneOf_SubMessage struct { + SubMessage *Subby `protobuf:"bytes,16,opt,name=sub_message,oneof"` +} + +func (*AllTypesOneOf_Field1) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field2) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field3) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field4) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field5) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field6) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field7) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field8) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field9) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field10) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field11) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field12) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field13) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field14) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field15) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_SubMessage) isAllTypesOneOf_TestOneof() {} + +func (m *AllTypesOneOf) GetTestOneof() isAllTypesOneOf_TestOneof { + if m != nil { + return m.TestOneof + } + return nil +} + +func (m *AllTypesOneOf) GetField1() float64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *AllTypesOneOf) GetField2() float32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *AllTypesOneOf) GetField3() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *AllTypesOneOf) GetField4() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field4); ok { + return x.Field4 + } + return 0 +} + +func (m *AllTypesOneOf) GetField5() uint32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field5); ok { + return x.Field5 + } + return 0 +} + +func (m *AllTypesOneOf) GetField6() uint64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field6); ok { + return x.Field6 + } + return 0 +} + +func (m *AllTypesOneOf) GetField7() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field7); ok { + return x.Field7 + } + return 0 +} + +func (m *AllTypesOneOf) GetField8() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field8); ok { + return x.Field8 + } + return 0 +} + +func (m *AllTypesOneOf) GetField9() uint32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field9); ok { + return x.Field9 + } + return 0 +} + +func (m *AllTypesOneOf) GetField10() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field10); ok { + return x.Field10 + } + return 0 +} + +func (m *AllTypesOneOf) GetField11() uint64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field11); ok { + return x.Field11 + } + return 0 +} + +func (m *AllTypesOneOf) GetField12() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field12); ok { + return x.Field12 + } + return 0 +} + +func (m *AllTypesOneOf) GetField13() bool { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field13); ok { + return x.Field13 + } + return false +} + +func (m *AllTypesOneOf) GetField14() string { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field14); ok { + return x.Field14 + } + return "" +} + +func (m *AllTypesOneOf) GetField15() []byte { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field15); ok { + return x.Field15 + } + return nil +} + +func (m *AllTypesOneOf) GetSubMessage() *Subby { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_SubMessage); ok { + return x.SubMessage + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*AllTypesOneOf) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _AllTypesOneOf_OneofMarshaler, _AllTypesOneOf_OneofUnmarshaler, []interface{}{ + (*AllTypesOneOf_Field1)(nil), + (*AllTypesOneOf_Field2)(nil), + (*AllTypesOneOf_Field3)(nil), + (*AllTypesOneOf_Field4)(nil), + (*AllTypesOneOf_Field5)(nil), + (*AllTypesOneOf_Field6)(nil), + (*AllTypesOneOf_Field7)(nil), + (*AllTypesOneOf_Field8)(nil), + (*AllTypesOneOf_Field9)(nil), + (*AllTypesOneOf_Field10)(nil), + (*AllTypesOneOf_Field11)(nil), + (*AllTypesOneOf_Field12)(nil), + (*AllTypesOneOf_Field13)(nil), + (*AllTypesOneOf_Field14)(nil), + (*AllTypesOneOf_Field15)(nil), + (*AllTypesOneOf_SubMessage)(nil), + } +} + +func _AllTypesOneOf_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*AllTypesOneOf) + // test_oneof + switch x := m.TestOneof.(type) { + case *AllTypesOneOf_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *AllTypesOneOf_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *AllTypesOneOf_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case *AllTypesOneOf_Field4: + _ = b.EncodeVarint(4<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field4)) + case *AllTypesOneOf_Field5: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field5)) + case *AllTypesOneOf_Field6: + _ = b.EncodeVarint(6<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field6)) + case *AllTypesOneOf_Field7: + _ = b.EncodeVarint(7<<3 | proto.WireVarint) + _ = b.EncodeZigzag32(uint64(x.Field7)) + case *AllTypesOneOf_Field8: + _ = b.EncodeVarint(8<<3 | proto.WireVarint) + _ = b.EncodeZigzag64(uint64(x.Field8)) + case *AllTypesOneOf_Field9: + _ = b.EncodeVarint(9<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field9)) + case *AllTypesOneOf_Field10: + _ = b.EncodeVarint(10<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field10)) + case *AllTypesOneOf_Field11: + _ = b.EncodeVarint(11<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field11)) + case *AllTypesOneOf_Field12: + _ = b.EncodeVarint(12<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field12)) + case *AllTypesOneOf_Field13: + t := uint64(0) + if x.Field13 { + t = 1 + } + _ = b.EncodeVarint(13<<3 | proto.WireVarint) + _ = b.EncodeVarint(t) + case *AllTypesOneOf_Field14: + _ = b.EncodeVarint(14<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field14) + case *AllTypesOneOf_Field15: + _ = b.EncodeVarint(15<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field15) + case *AllTypesOneOf_SubMessage: + _ = b.EncodeVarint(16<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("AllTypesOneOf.TestOneof has unexpected type %T", x) + } + return nil +} + +func _AllTypesOneOf_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*AllTypesOneOf) + switch tag { + case 1: // test_oneof.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field1{math.Float64frombits(x)} + return true, err + case 2: // test_oneof.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // test_oneof.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field3{int32(x)} + return true, err + case 4: // test_oneof.Field4 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field4{int64(x)} + return true, err + case 5: // test_oneof.Field5 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field5{uint32(x)} + return true, err + case 6: // test_oneof.Field6 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field6{x} + return true, err + case 7: // test_oneof.Field7 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag32() + m.TestOneof = &AllTypesOneOf_Field7{int32(x)} + return true, err + case 8: // test_oneof.Field8 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag64() + m.TestOneof = &AllTypesOneOf_Field8{int64(x)} + return true, err + case 9: // test_oneof.Field9 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field9{uint32(x)} + return true, err + case 10: // test_oneof.Field10 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field10{int32(x)} + return true, err + case 11: // test_oneof.Field11 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field11{x} + return true, err + case 12: // test_oneof.Field12 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field12{int64(x)} + return true, err + case 13: // test_oneof.Field13 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field13{x != 0} + return true, err + case 14: // test_oneof.Field14 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.TestOneof = &AllTypesOneOf_Field14{x} + return true, err + case 15: // test_oneof.Field15 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.TestOneof = &AllTypesOneOf_Field15{x} + return true, err + case 16: // test_oneof.sub_message + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.TestOneof = &AllTypesOneOf_SubMessage{msg} + return true, err + default: + return false, nil + } +} + +type TwoOneofs struct { + // Types that are valid to be assigned to One: + // *TwoOneofs_Field1 + // *TwoOneofs_Field2 + // *TwoOneofs_Field3 + One isTwoOneofs_One `protobuf_oneof:"one"` + // Types that are valid to be assigned to Two: + // *TwoOneofs_Field34 + // *TwoOneofs_Field35 + // *TwoOneofs_SubMessage2 + Two isTwoOneofs_Two `protobuf_oneof:"two"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TwoOneofs) Reset() { *m = TwoOneofs{} } +func (*TwoOneofs) ProtoMessage() {} + +type isTwoOneofs_One interface { + isTwoOneofs_One() + Equal(interface{}) bool + VerboseEqual(interface{}) error + Size() int +} +type isTwoOneofs_Two interface { + isTwoOneofs_Two() + Equal(interface{}) bool + VerboseEqual(interface{}) error + Size() int +} + +type TwoOneofs_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,oneof"` +} +type TwoOneofs_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,oneof"` +} +type TwoOneofs_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,oneof"` +} +type TwoOneofs_Field34 struct { + Field34 string `protobuf:"bytes,34,opt,name=Field34,oneof"` +} +type TwoOneofs_Field35 struct { + Field35 []byte `protobuf:"bytes,35,opt,name=Field35,oneof"` +} +type TwoOneofs_SubMessage2 struct { + SubMessage2 *Subby `protobuf:"bytes,36,opt,name=sub_message2,oneof"` +} + +func (*TwoOneofs_Field1) isTwoOneofs_One() {} +func (*TwoOneofs_Field2) isTwoOneofs_One() {} +func (*TwoOneofs_Field3) isTwoOneofs_One() {} +func (*TwoOneofs_Field34) isTwoOneofs_Two() {} +func (*TwoOneofs_Field35) isTwoOneofs_Two() {} +func (*TwoOneofs_SubMessage2) isTwoOneofs_Two() {} + +func (m *TwoOneofs) GetOne() isTwoOneofs_One { + if m != nil { + return m.One + } + return nil +} +func (m *TwoOneofs) GetTwo() isTwoOneofs_Two { + if m != nil { + return m.Two + } + return nil +} + +func (m *TwoOneofs) GetField1() float64 { + if x, ok := m.GetOne().(*TwoOneofs_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *TwoOneofs) GetField2() float32 { + if x, ok := m.GetOne().(*TwoOneofs_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *TwoOneofs) GetField3() int32 { + if x, ok := m.GetOne().(*TwoOneofs_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *TwoOneofs) GetField34() string { + if x, ok := m.GetTwo().(*TwoOneofs_Field34); ok { + return x.Field34 + } + return "" +} + +func (m *TwoOneofs) GetField35() []byte { + if x, ok := m.GetTwo().(*TwoOneofs_Field35); ok { + return x.Field35 + } + return nil +} + +func (m *TwoOneofs) GetSubMessage2() *Subby { + if x, ok := m.GetTwo().(*TwoOneofs_SubMessage2); ok { + return x.SubMessage2 + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*TwoOneofs) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _TwoOneofs_OneofMarshaler, _TwoOneofs_OneofUnmarshaler, []interface{}{ + (*TwoOneofs_Field1)(nil), + (*TwoOneofs_Field2)(nil), + (*TwoOneofs_Field3)(nil), + (*TwoOneofs_Field34)(nil), + (*TwoOneofs_Field35)(nil), + (*TwoOneofs_SubMessage2)(nil), + } +} + +func _TwoOneofs_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*TwoOneofs) + // one + switch x := m.One.(type) { + case *TwoOneofs_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *TwoOneofs_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *TwoOneofs_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case nil: + default: + return fmt.Errorf("TwoOneofs.One has unexpected type %T", x) + } + // two + switch x := m.Two.(type) { + case *TwoOneofs_Field34: + _ = b.EncodeVarint(34<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field34) + case *TwoOneofs_Field35: + _ = b.EncodeVarint(35<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field35) + case *TwoOneofs_SubMessage2: + _ = b.EncodeVarint(36<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage2); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("TwoOneofs.Two has unexpected type %T", x) + } + return nil +} + +func _TwoOneofs_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*TwoOneofs) + switch tag { + case 1: // one.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.One = &TwoOneofs_Field1{math.Float64frombits(x)} + return true, err + case 2: // one.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.One = &TwoOneofs_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // one.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.One = &TwoOneofs_Field3{int32(x)} + return true, err + case 34: // two.Field34 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Two = &TwoOneofs_Field34{x} + return true, err + case 35: // two.Field35 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.Two = &TwoOneofs_Field35{x} + return true, err + case 36: // two.sub_message2 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.Two = &TwoOneofs_SubMessage2{msg} + return true, err + default: + return false, nil + } +} + +type CustomOneof struct { + // Types that are valid to be assigned to Custom: + // *CustomOneof_Stringy + // *CustomOneof_CustomType + // *CustomOneof_CastType + // *CustomOneof_MyCustomName + Custom isCustomOneof_Custom `protobuf_oneof:"custom"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomOneof) Reset() { *m = CustomOneof{} } +func (*CustomOneof) ProtoMessage() {} + +type isCustomOneof_Custom interface { + isCustomOneof_Custom() + Equal(interface{}) bool + VerboseEqual(interface{}) error + Size() int +} + +type CustomOneof_Stringy struct { + Stringy string `protobuf:"bytes,34,opt,name=Stringy,oneof"` +} +type CustomOneof_CustomType struct { + CustomType github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,35,opt,name=CustomType,oneof,customtype=github.com/gogo/protobuf/test/custom.Uint128"` +} +type CustomOneof_CastType struct { + CastType github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,36,opt,name=CastType,oneof,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type"` +} +type CustomOneof_MyCustomName struct { + MyCustomName int64 `protobuf:"varint,37,opt,name=CustomName,oneof"` +} + +func (*CustomOneof_Stringy) isCustomOneof_Custom() {} +func (*CustomOneof_CustomType) isCustomOneof_Custom() {} +func (*CustomOneof_CastType) isCustomOneof_Custom() {} +func (*CustomOneof_MyCustomName) isCustomOneof_Custom() {} + +func (m *CustomOneof) GetCustom() isCustomOneof_Custom { + if m != nil { + return m.Custom + } + return nil +} + +func (m *CustomOneof) GetStringy() string { + if x, ok := m.GetCustom().(*CustomOneof_Stringy); ok { + return x.Stringy + } + return "" +} + +func (m *CustomOneof) GetCastType() github_com_gogo_protobuf_test_casttype.MyUint64Type { + if x, ok := m.GetCustom().(*CustomOneof_CastType); ok { + return x.CastType + } + return 0 +} + +func (m *CustomOneof) GetMyCustomName() int64 { + if x, ok := m.GetCustom().(*CustomOneof_MyCustomName); ok { + return x.MyCustomName + } + return 0 +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*CustomOneof) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _CustomOneof_OneofMarshaler, _CustomOneof_OneofUnmarshaler, []interface{}{ + (*CustomOneof_Stringy)(nil), + (*CustomOneof_CustomType)(nil), + (*CustomOneof_CastType)(nil), + (*CustomOneof_MyCustomName)(nil), + } +} + +func _CustomOneof_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*CustomOneof) + // custom + switch x := m.Custom.(type) { + case *CustomOneof_Stringy: + _ = b.EncodeVarint(34<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Stringy) + case *CustomOneof_CustomType: + _ = b.EncodeVarint(35<<3 | proto.WireBytes) + data, err := x.CustomType.Marshal() + if err != nil { + return err + } + _ = b.EncodeRawBytes(data) + case *CustomOneof_CastType: + _ = b.EncodeVarint(36<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.CastType)) + case *CustomOneof_MyCustomName: + _ = b.EncodeVarint(37<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.MyCustomName)) + case nil: + default: + return fmt.Errorf("CustomOneof.Custom has unexpected type %T", x) + } + return nil +} + +func _CustomOneof_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*CustomOneof) + switch tag { + case 34: // custom.Stringy + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Custom = &CustomOneof_Stringy{x} + return true, err + case 35: // custom.CustomType + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + if err != nil { + return true, err + } + var cc github_com_gogo_protobuf_test_custom.Uint128 + c := &cc + err = c.Unmarshal(x) + m.Custom = &CustomOneof_CustomType{*c} + return true, err + case 36: // custom.CastType + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Custom = &CustomOneof_CastType{github_com_gogo_protobuf_test_casttype.MyUint64Type(x)} + return true, err + case 37: // custom.CustomName + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Custom = &CustomOneof_MyCustomName{int64(x)} + return true, err + default: + return false, nil + } +} + +func (this *Subby) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *AllTypesOneOf) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *TwoOneofs) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *CustomOneof) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func OneDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unmarshaler/one.proto"), + Package: func(v string) *string { return &v }("one"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Subby"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("sub"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("AllTypesOneOf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("sub_message"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(0), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("test_oneof")}}, + }, {Name: func(v string) *string { return &v }("TwoOneofs"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field34"), + Number: func(v int32) *int32 { return &v }(34), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("Field35"), + Number: func(v int32) *int32 { return &v }(35), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("sub_message2"), + Number: func(v int32) *int32 { return &v }(36), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(1), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("one")}, {Name: func(v string) *string { return &v }("two")}}, + }, {Name: func(v string) *string { return &v }("CustomOneof"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Stringy"), + Number: func(v int32) *int32 { return &v }(34), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CustomType"), + Number: func(v int32) *int32 { return &v }(35), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }, {Name: func(v string) *string { return &v }("CastType"), + Number: func(v int32) *int32 { return &v }(36), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("CustomName"), + Number: func(v int32) *int32 { return &v }(37), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0xc, 0x4d, 0x79, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4e, 0x61, 0x6d, 0x65})}}, + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("custom")}}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (this *Subby) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Subby) + if !ok { + return fmt.Errorf("that is not of type *Subby") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Subby but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Subbybut is not nil && this == nil") + } + if this.Sub != nil && that1.Sub != nil { + if *this.Sub != *that1.Sub { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", *this.Sub, *that1.Sub) + } + } else if this.Sub != nil { + return fmt.Errorf("this.Sub == nil && that.Sub != nil") + } else if that1.Sub != nil { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Subby) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Subby) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Sub != nil && that1.Sub != nil { + if *this.Sub != *that1.Sub { + return false + } + } else if this.Sub != nil { + return false + } else if that1.Sub != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllTypesOneOf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOfbut is not nil && this == nil") + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return fmt.Errorf("this.TestOneof != nil && that1.TestOneof == nil") + } + } else if this.TestOneof == nil { + return fmt.Errorf("this.TestOneof == nil && that1.TestOneof != nil") + } else if err := this.TestOneof.VerboseEqual(that1.TestOneof); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AllTypesOneOf_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field1) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *AllTypesOneOf_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field2) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *AllTypesOneOf_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field3) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *AllTypesOneOf_Field4) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field4) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field4") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field4 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field4but is not nil && this == nil") + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + return nil +} +func (this *AllTypesOneOf_Field5) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field5) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field5") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field5 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field5but is not nil && this == nil") + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + return nil +} +func (this *AllTypesOneOf_Field6) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field6) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field6") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field6 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field6but is not nil && this == nil") + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + return nil +} +func (this *AllTypesOneOf_Field7) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field7) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field7") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field7 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field7but is not nil && this == nil") + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + return nil +} +func (this *AllTypesOneOf_Field8) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field8) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field8") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field8 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field8but is not nil && this == nil") + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + return nil +} +func (this *AllTypesOneOf_Field9) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field9) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field9") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field9 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field9but is not nil && this == nil") + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + return nil +} +func (this *AllTypesOneOf_Field10) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field10) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field10") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field10 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field10but is not nil && this == nil") + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + return nil +} +func (this *AllTypesOneOf_Field11) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field11) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field11") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field11 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field11but is not nil && this == nil") + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + return nil +} +func (this *AllTypesOneOf_Field12) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field12) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field12") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field12 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field12but is not nil && this == nil") + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + return nil +} +func (this *AllTypesOneOf_Field13) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field13) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field13") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field13 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field13but is not nil && this == nil") + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + return nil +} +func (this *AllTypesOneOf_Field14) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field14) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field14") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field14 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field14but is not nil && this == nil") + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + return nil +} +func (this *AllTypesOneOf_Field15) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field15) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field15") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field15 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field15but is not nil && this == nil") + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + return nil +} +func (this *AllTypesOneOf_SubMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_SubMessage) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_SubMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_SubMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_SubMessagebut is not nil && this == nil") + } + if !this.SubMessage.Equal(that1.SubMessage) { + return fmt.Errorf("SubMessage this(%v) Not Equal that(%v)", this.SubMessage, that1.SubMessage) + } + return nil +} +func (this *AllTypesOneOf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return false + } + } else if this.TestOneof == nil { + return false + } else if !this.TestOneof.Equal(that1.TestOneof) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllTypesOneOf_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *AllTypesOneOf_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *AllTypesOneOf_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *AllTypesOneOf_Field4) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field4) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field4 != that1.Field4 { + return false + } + return true +} +func (this *AllTypesOneOf_Field5) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field5) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field5 != that1.Field5 { + return false + } + return true +} +func (this *AllTypesOneOf_Field6) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field6) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field6 != that1.Field6 { + return false + } + return true +} +func (this *AllTypesOneOf_Field7) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field7) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field7 != that1.Field7 { + return false + } + return true +} +func (this *AllTypesOneOf_Field8) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field8) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field8 != that1.Field8 { + return false + } + return true +} +func (this *AllTypesOneOf_Field9) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field9) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field9 != that1.Field9 { + return false + } + return true +} +func (this *AllTypesOneOf_Field10) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field10) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field10 != that1.Field10 { + return false + } + return true +} +func (this *AllTypesOneOf_Field11) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field11) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field11 != that1.Field11 { + return false + } + return true +} +func (this *AllTypesOneOf_Field12) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field12) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field12 != that1.Field12 { + return false + } + return true +} +func (this *AllTypesOneOf_Field13) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field13) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field13 != that1.Field13 { + return false + } + return true +} +func (this *AllTypesOneOf_Field14) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field14) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field14 != that1.Field14 { + return false + } + return true +} +func (this *AllTypesOneOf_Field15) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field15) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + return true +} +func (this *AllTypesOneOf_SubMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_SubMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage.Equal(that1.SubMessage) { + return false + } + return true +} +func (this *TwoOneofs) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofsbut is not nil && this == nil") + } + if that1.One == nil { + if this.One != nil { + return fmt.Errorf("this.One != nil && that1.One == nil") + } + } else if this.One == nil { + return fmt.Errorf("this.One == nil && that1.One != nil") + } else if err := this.One.VerboseEqual(that1.One); err != nil { + return err + } + if that1.Two == nil { + if this.Two != nil { + return fmt.Errorf("this.Two != nil && that1.Two == nil") + } + } else if this.Two == nil { + return fmt.Errorf("this.Two == nil && that1.Two != nil") + } else if err := this.Two.VerboseEqual(that1.Two); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *TwoOneofs_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field1) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *TwoOneofs_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field2) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *TwoOneofs_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field3) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *TwoOneofs_Field34) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field34) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field34") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field34 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field34but is not nil && this == nil") + } + if this.Field34 != that1.Field34 { + return fmt.Errorf("Field34 this(%v) Not Equal that(%v)", this.Field34, that1.Field34) + } + return nil +} +func (this *TwoOneofs_Field35) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field35) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field35") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field35 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field35but is not nil && this == nil") + } + if !bytes.Equal(this.Field35, that1.Field35) { + return fmt.Errorf("Field35 this(%v) Not Equal that(%v)", this.Field35, that1.Field35) + } + return nil +} +func (this *TwoOneofs_SubMessage2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_SubMessage2) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_SubMessage2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_SubMessage2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_SubMessage2but is not nil && this == nil") + } + if !this.SubMessage2.Equal(that1.SubMessage2) { + return fmt.Errorf("SubMessage2 this(%v) Not Equal that(%v)", this.SubMessage2, that1.SubMessage2) + } + return nil +} +func (this *TwoOneofs) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.One == nil { + if this.One != nil { + return false + } + } else if this.One == nil { + return false + } else if !this.One.Equal(that1.One) { + return false + } + if that1.Two == nil { + if this.Two != nil { + return false + } + } else if this.Two == nil { + return false + } else if !this.Two.Equal(that1.Two) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *TwoOneofs_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *TwoOneofs_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *TwoOneofs_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *TwoOneofs_Field34) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field34) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field34 != that1.Field34 { + return false + } + return true +} +func (this *TwoOneofs_Field35) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field35) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field35, that1.Field35) { + return false + } + return true +} +func (this *TwoOneofs_SubMessage2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_SubMessage2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage2.Equal(that1.SubMessage2) { + return false + } + return true +} +func (this *CustomOneof) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneofbut is not nil && this == nil") + } + if that1.Custom == nil { + if this.Custom != nil { + return fmt.Errorf("this.Custom != nil && that1.Custom == nil") + } + } else if this.Custom == nil { + return fmt.Errorf("this.Custom == nil && that1.Custom != nil") + } else if err := this.Custom.VerboseEqual(that1.Custom); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomOneof_Stringy) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_Stringy) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_Stringy") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_Stringy but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_Stringybut is not nil && this == nil") + } + if this.Stringy != that1.Stringy { + return fmt.Errorf("Stringy this(%v) Not Equal that(%v)", this.Stringy, that1.Stringy) + } + return nil +} +func (this *CustomOneof_CustomType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_CustomType) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_CustomType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_CustomType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_CustomTypebut is not nil && this == nil") + } + if !this.CustomType.Equal(that1.CustomType) { + return fmt.Errorf("CustomType this(%v) Not Equal that(%v)", this.CustomType, that1.CustomType) + } + return nil +} +func (this *CustomOneof_CastType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_CastType) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_CastType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_CastType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_CastTypebut is not nil && this == nil") + } + if this.CastType != that1.CastType { + return fmt.Errorf("CastType this(%v) Not Equal that(%v)", this.CastType, that1.CastType) + } + return nil +} +func (this *CustomOneof_MyCustomName) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_MyCustomName) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_MyCustomName") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_MyCustomName but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_MyCustomNamebut is not nil && this == nil") + } + if this.MyCustomName != that1.MyCustomName { + return fmt.Errorf("MyCustomName this(%v) Not Equal that(%v)", this.MyCustomName, that1.MyCustomName) + } + return nil +} +func (this *CustomOneof) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Custom == nil { + if this.Custom != nil { + return false + } + } else if this.Custom == nil { + return false + } else if !this.Custom.Equal(that1.Custom) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomOneof_Stringy) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_Stringy) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Stringy != that1.Stringy { + return false + } + return true +} +func (this *CustomOneof_CustomType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_CustomType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.CustomType.Equal(that1.CustomType) { + return false + } + return true +} +func (this *CustomOneof_CastType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_CastType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.CastType != that1.CastType { + return false + } + return true +} +func (this *CustomOneof_MyCustomName) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_MyCustomName) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.MyCustomName != that1.MyCustomName { + return false + } + return true +} +func (this *Subby) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&one.Subby{") + if this.Sub != nil { + s = append(s, "Sub: "+valueToGoStringOne(this.Sub, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllTypesOneOf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 20) + s = append(s, "&one.AllTypesOneOf{") + if this.TestOneof != nil { + s = append(s, "TestOneof: "+fmt.Sprintf("%#v", this.TestOneof)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllTypesOneOf_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field4) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field4{` + + `Field4:` + fmt.Sprintf("%#v", this.Field4) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field5) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field5{` + + `Field5:` + fmt.Sprintf("%#v", this.Field5) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field6) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field6{` + + `Field6:` + fmt.Sprintf("%#v", this.Field6) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field7) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field7{` + + `Field7:` + fmt.Sprintf("%#v", this.Field7) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field8) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field8{` + + `Field8:` + fmt.Sprintf("%#v", this.Field8) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field9) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field9{` + + `Field9:` + fmt.Sprintf("%#v", this.Field9) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field10) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field10{` + + `Field10:` + fmt.Sprintf("%#v", this.Field10) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field11) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field11{` + + `Field11:` + fmt.Sprintf("%#v", this.Field11) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field12) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field12{` + + `Field12:` + fmt.Sprintf("%#v", this.Field12) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field13) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field13{` + + `Field13:` + fmt.Sprintf("%#v", this.Field13) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field14) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field14{` + + `Field14:` + fmt.Sprintf("%#v", this.Field14) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field15) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field15{` + + `Field15:` + fmt.Sprintf("%#v", this.Field15) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_SubMessage) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_SubMessage{` + + `SubMessage:` + fmt.Sprintf("%#v", this.SubMessage) + `}`}, ", ") + return s +} +func (this *TwoOneofs) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 10) + s = append(s, "&one.TwoOneofs{") + if this.One != nil { + s = append(s, "One: "+fmt.Sprintf("%#v", this.One)+",\n") + } + if this.Two != nil { + s = append(s, "Two: "+fmt.Sprintf("%#v", this.Two)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *TwoOneofs_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field34) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field34{` + + `Field34:` + fmt.Sprintf("%#v", this.Field34) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field35) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field35{` + + `Field35:` + fmt.Sprintf("%#v", this.Field35) + `}`}, ", ") + return s +} +func (this *TwoOneofs_SubMessage2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_SubMessage2{` + + `SubMessage2:` + fmt.Sprintf("%#v", this.SubMessage2) + `}`}, ", ") + return s +} +func (this *CustomOneof) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&one.CustomOneof{") + if this.Custom != nil { + s = append(s, "Custom: "+fmt.Sprintf("%#v", this.Custom)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomOneof_Stringy) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_Stringy{` + + `Stringy:` + fmt.Sprintf("%#v", this.Stringy) + `}`}, ", ") + return s +} +func (this *CustomOneof_CustomType) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_CustomType{` + + `CustomType:` + fmt.Sprintf("%#v", this.CustomType) + `}`}, ", ") + return s +} +func (this *CustomOneof_CastType) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_CastType{` + + `CastType:` + fmt.Sprintf("%#v", this.CastType) + `}`}, ", ") + return s +} +func (this *CustomOneof_MyCustomName) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_MyCustomName{` + + `MyCustomName:` + fmt.Sprintf("%#v", this.MyCustomName) + `}`}, ", ") + return s +} +func valueToGoStringOne(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringOne(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedSubby(r randyOne, easy bool) *Subby { + this := &Subby{} + if r.Intn(10) != 0 { + v1 := randStringOne(r) + this.Sub = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 2) + } + return this +} + +func NewPopulatedAllTypesOneOf(r randyOne, easy bool) *AllTypesOneOf { + this := &AllTypesOneOf{} + oneofNumber_TestOneof := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}[r.Intn(16)] + switch oneofNumber_TestOneof { + case 1: + this.TestOneof = NewPopulatedAllTypesOneOf_Field1(r, easy) + case 2: + this.TestOneof = NewPopulatedAllTypesOneOf_Field2(r, easy) + case 3: + this.TestOneof = NewPopulatedAllTypesOneOf_Field3(r, easy) + case 4: + this.TestOneof = NewPopulatedAllTypesOneOf_Field4(r, easy) + case 5: + this.TestOneof = NewPopulatedAllTypesOneOf_Field5(r, easy) + case 6: + this.TestOneof = NewPopulatedAllTypesOneOf_Field6(r, easy) + case 7: + this.TestOneof = NewPopulatedAllTypesOneOf_Field7(r, easy) + case 8: + this.TestOneof = NewPopulatedAllTypesOneOf_Field8(r, easy) + case 9: + this.TestOneof = NewPopulatedAllTypesOneOf_Field9(r, easy) + case 10: + this.TestOneof = NewPopulatedAllTypesOneOf_Field10(r, easy) + case 11: + this.TestOneof = NewPopulatedAllTypesOneOf_Field11(r, easy) + case 12: + this.TestOneof = NewPopulatedAllTypesOneOf_Field12(r, easy) + case 13: + this.TestOneof = NewPopulatedAllTypesOneOf_Field13(r, easy) + case 14: + this.TestOneof = NewPopulatedAllTypesOneOf_Field14(r, easy) + case 15: + this.TestOneof = NewPopulatedAllTypesOneOf_Field15(r, easy) + case 16: + this.TestOneof = NewPopulatedAllTypesOneOf_SubMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 17) + } + return this +} + +func NewPopulatedAllTypesOneOf_Field1(r randyOne, easy bool) *AllTypesOneOf_Field1 { + this := &AllTypesOneOf_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field2(r randyOne, easy bool) *AllTypesOneOf_Field2 { + this := &AllTypesOneOf_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field3(r randyOne, easy bool) *AllTypesOneOf_Field3 { + this := &AllTypesOneOf_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field4(r randyOne, easy bool) *AllTypesOneOf_Field4 { + this := &AllTypesOneOf_Field4{} + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field5(r randyOne, easy bool) *AllTypesOneOf_Field5 { + this := &AllTypesOneOf_Field5{} + this.Field5 = uint32(r.Uint32()) + return this +} +func NewPopulatedAllTypesOneOf_Field6(r randyOne, easy bool) *AllTypesOneOf_Field6 { + this := &AllTypesOneOf_Field6{} + this.Field6 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedAllTypesOneOf_Field7(r randyOne, easy bool) *AllTypesOneOf_Field7 { + this := &AllTypesOneOf_Field7{} + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field8(r randyOne, easy bool) *AllTypesOneOf_Field8 { + this := &AllTypesOneOf_Field8{} + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field9(r randyOne, easy bool) *AllTypesOneOf_Field9 { + this := &AllTypesOneOf_Field9{} + this.Field9 = uint32(r.Uint32()) + return this +} +func NewPopulatedAllTypesOneOf_Field10(r randyOne, easy bool) *AllTypesOneOf_Field10 { + this := &AllTypesOneOf_Field10{} + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field11(r randyOne, easy bool) *AllTypesOneOf_Field11 { + this := &AllTypesOneOf_Field11{} + this.Field11 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedAllTypesOneOf_Field12(r randyOne, easy bool) *AllTypesOneOf_Field12 { + this := &AllTypesOneOf_Field12{} + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field13(r randyOne, easy bool) *AllTypesOneOf_Field13 { + this := &AllTypesOneOf_Field13{} + this.Field13 = bool(bool(r.Intn(2) == 0)) + return this +} +func NewPopulatedAllTypesOneOf_Field14(r randyOne, easy bool) *AllTypesOneOf_Field14 { + this := &AllTypesOneOf_Field14{} + this.Field14 = randStringOne(r) + return this +} +func NewPopulatedAllTypesOneOf_Field15(r randyOne, easy bool) *AllTypesOneOf_Field15 { + this := &AllTypesOneOf_Field15{} + v2 := r.Intn(100) + this.Field15 = make([]byte, v2) + for i := 0; i < v2; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedAllTypesOneOf_SubMessage(r randyOne, easy bool) *AllTypesOneOf_SubMessage { + this := &AllTypesOneOf_SubMessage{} + this.SubMessage = NewPopulatedSubby(r, easy) + return this +} +func NewPopulatedTwoOneofs(r randyOne, easy bool) *TwoOneofs { + this := &TwoOneofs{} + oneofNumber_One := []int32{1, 2, 3}[r.Intn(3)] + switch oneofNumber_One { + case 1: + this.One = NewPopulatedTwoOneofs_Field1(r, easy) + case 2: + this.One = NewPopulatedTwoOneofs_Field2(r, easy) + case 3: + this.One = NewPopulatedTwoOneofs_Field3(r, easy) + } + oneofNumber_Two := []int32{34, 35, 36}[r.Intn(3)] + switch oneofNumber_Two { + case 34: + this.Two = NewPopulatedTwoOneofs_Field34(r, easy) + case 35: + this.Two = NewPopulatedTwoOneofs_Field35(r, easy) + case 36: + this.Two = NewPopulatedTwoOneofs_SubMessage2(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 37) + } + return this +} + +func NewPopulatedTwoOneofs_Field1(r randyOne, easy bool) *TwoOneofs_Field1 { + this := &TwoOneofs_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field2(r randyOne, easy bool) *TwoOneofs_Field2 { + this := &TwoOneofs_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field3(r randyOne, easy bool) *TwoOneofs_Field3 { + this := &TwoOneofs_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field34(r randyOne, easy bool) *TwoOneofs_Field34 { + this := &TwoOneofs_Field34{} + this.Field34 = randStringOne(r) + return this +} +func NewPopulatedTwoOneofs_Field35(r randyOne, easy bool) *TwoOneofs_Field35 { + this := &TwoOneofs_Field35{} + v3 := r.Intn(100) + this.Field35 = make([]byte, v3) + for i := 0; i < v3; i++ { + this.Field35[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedTwoOneofs_SubMessage2(r randyOne, easy bool) *TwoOneofs_SubMessage2 { + this := &TwoOneofs_SubMessage2{} + this.SubMessage2 = NewPopulatedSubby(r, easy) + return this +} +func NewPopulatedCustomOneof(r randyOne, easy bool) *CustomOneof { + this := &CustomOneof{} + oneofNumber_Custom := []int32{34, 35, 36, 37}[r.Intn(4)] + switch oneofNumber_Custom { + case 34: + this.Custom = NewPopulatedCustomOneof_Stringy(r, easy) + case 35: + this.Custom = NewPopulatedCustomOneof_CustomType(r, easy) + case 36: + this.Custom = NewPopulatedCustomOneof_CastType(r, easy) + case 37: + this.Custom = NewPopulatedCustomOneof_MyCustomName(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 38) + } + return this +} + +func NewPopulatedCustomOneof_Stringy(r randyOne, easy bool) *CustomOneof_Stringy { + this := &CustomOneof_Stringy{} + this.Stringy = randStringOne(r) + return this +} +func NewPopulatedCustomOneof_CustomType(r randyOne, easy bool) *CustomOneof_CustomType { + this := &CustomOneof_CustomType{} + v4 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.CustomType = *v4 + return this +} +func NewPopulatedCustomOneof_CastType(r randyOne, easy bool) *CustomOneof_CastType { + this := &CustomOneof_CastType{} + this.CastType = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + return this +} +func NewPopulatedCustomOneof_MyCustomName(r randyOne, easy bool) *CustomOneof_MyCustomName { + this := &CustomOneof_MyCustomName{} + this.MyCustomName = int64(r.Int63()) + if r.Intn(2) == 0 { + this.MyCustomName *= -1 + } + return this +} + +type randyOne interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneOne(r randyOne) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringOne(r randyOne) string { + v5 := r.Intn(100) + tmps := make([]rune, v5) + for i := 0; i < v5; i++ { + tmps[i] = randUTF8RuneOne(r) + } + return string(tmps) +} +func randUnrecognizedOne(r randyOne, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldOne(data, r, fieldNumber, wire) + } + return data +} +func randFieldOne(data []byte, r randyOne, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateOne(data, uint64(key)) + v6 := r.Int63() + if r.Intn(2) == 0 { + v6 *= -1 + } + data = encodeVarintPopulateOne(data, uint64(v6)) + case 1: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateOne(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateOne(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateOne(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Subby) Size() (n int) { + var l int + _ = l + if m.Sub != nil { + l = len(*m.Sub) + n += 1 + l + sovOne(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllTypesOneOf) Size() (n int) { + var l int + _ = l + if m.TestOneof != nil { + n += m.TestOneof.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllTypesOneOf_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *AllTypesOneOf_Field4) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field4)) + return n +} +func (m *AllTypesOneOf_Field5) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field5)) + return n +} +func (m *AllTypesOneOf_Field6) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field6)) + return n +} +func (m *AllTypesOneOf_Field7) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field7)) + return n +} +func (m *AllTypesOneOf_Field8) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field8)) + return n +} +func (m *AllTypesOneOf_Field9) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field10) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field11) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field12) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field13) Size() (n int) { + var l int + _ = l + n += 2 + return n +} +func (m *AllTypesOneOf_Field14) Size() (n int) { + var l int + _ = l + l = len(m.Field14) + n += 1 + l + sovOne(uint64(l)) + return n +} +func (m *AllTypesOneOf_Field15) Size() (n int) { + var l int + _ = l + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovOne(uint64(l)) + } + return n +} +func (m *AllTypesOneOf_SubMessage) Size() (n int) { + var l int + _ = l + if m.SubMessage != nil { + l = m.SubMessage.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *TwoOneofs) Size() (n int) { + var l int + _ = l + if m.One != nil { + n += m.One.Size() + } + if m.Two != nil { + n += m.Two.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TwoOneofs_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *TwoOneofs_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *TwoOneofs_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *TwoOneofs_Field34) Size() (n int) { + var l int + _ = l + l = len(m.Field34) + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *TwoOneofs_Field35) Size() (n int) { + var l int + _ = l + if m.Field35 != nil { + l = len(m.Field35) + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *TwoOneofs_SubMessage2) Size() (n int) { + var l int + _ = l + if m.SubMessage2 != nil { + l = m.SubMessage2.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *CustomOneof) Size() (n int) { + var l int + _ = l + if m.Custom != nil { + n += m.Custom.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomOneof_Stringy) Size() (n int) { + var l int + _ = l + l = len(m.Stringy) + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *CustomOneof_CustomType) Size() (n int) { + var l int + _ = l + l = m.CustomType.Size() + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *CustomOneof_CastType) Size() (n int) { + var l int + _ = l + n += 2 + sovOne(uint64(m.CastType)) + return n +} +func (m *CustomOneof_MyCustomName) Size() (n int) { + var l int + _ = l + n += 2 + sovOne(uint64(m.MyCustomName)) + return n +} + +func sovOne(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozOne(x uint64) (n int) { + return sovOne(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Subby) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Subby{`, + `Sub:` + valueToStringOne(this.Sub) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf{`, + `TestOneof:` + fmt.Sprintf("%v", this.TestOneof) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field4) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field4{`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field5) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field5{`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field6) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field6{`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field7) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field7{`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field8) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field8{`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field9) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field9{`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field10) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field10{`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field11) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field11{`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field12) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field12{`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field13) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field13{`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field14) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field14{`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field15) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field15{`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_SubMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_SubMessage{`, + `SubMessage:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs{`, + `One:` + fmt.Sprintf("%v", this.One) + `,`, + `Two:` + fmt.Sprintf("%v", this.Two) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field34) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field34{`, + `Field34:` + fmt.Sprintf("%v", this.Field34) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field35) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field35{`, + `Field35:` + fmt.Sprintf("%v", this.Field35) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_SubMessage2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_SubMessage2{`, + `SubMessage2:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage2), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof{`, + `Custom:` + fmt.Sprintf("%v", this.Custom) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_Stringy) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_Stringy{`, + `Stringy:` + fmt.Sprintf("%v", this.Stringy) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_CustomType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_CustomType{`, + `CustomType:` + fmt.Sprintf("%v", this.CustomType) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_CastType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_CastType{`, + `CastType:` + fmt.Sprintf("%v", this.CastType) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_MyCustomName) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_MyCustomName{`, + `MyCustomName:` + fmt.Sprintf("%v", this.MyCustomName) + `,`, + `}`, + }, "") + return s +} +func valueToStringOne(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Subby) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Subby: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Subby: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sub", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Sub = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOne(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOne + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AllTypesOneOf) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AllTypesOneOf: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AllTypesOneOf: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.TestOneof = &AllTypesOneOf_Field1{float64(math.Float64frombits(v))} + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.TestOneof = &AllTypesOneOf_Field2{float32(math.Float32frombits(v))} + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &AllTypesOneOf_Field3{v} + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &AllTypesOneOf_Field4{v} + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &AllTypesOneOf_Field5{v} + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &AllTypesOneOf_Field6{v} + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.TestOneof = &AllTypesOneOf_Field7{v} + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.TestOneof = &AllTypesOneOf_Field8{int64(v)} + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.TestOneof = &AllTypesOneOf_Field9{v} + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.TestOneof = &AllTypesOneOf_Field10{v} + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.TestOneof = &AllTypesOneOf_Field11{v} + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.TestOneof = &AllTypesOneOf_Field12{v} + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.TestOneof = &AllTypesOneOf_Field13{b} + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TestOneof = &AllTypesOneOf_Field14{string(data[iNdEx:postIndex])} + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := make([]byte, postIndex-iNdEx) + copy(v, data[iNdEx:postIndex]) + m.TestOneof = &AllTypesOneOf_Field15{v} + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &Subby{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.TestOneof = &AllTypesOneOf_SubMessage{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOne(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOne + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TwoOneofs) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TwoOneofs: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TwoOneofs: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.One = &TwoOneofs_Field1{float64(math.Float64frombits(v))} + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.One = &TwoOneofs_Field2{float32(math.Float32frombits(v))} + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.One = &TwoOneofs_Field3{v} + case 34: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field34", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Two = &TwoOneofs_Field34{string(data[iNdEx:postIndex])} + iNdEx = postIndex + case 35: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field35", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := make([]byte, postIndex-iNdEx) + copy(v, data[iNdEx:postIndex]) + m.Two = &TwoOneofs_Field35{v} + iNdEx = postIndex + case 36: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubMessage2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &Subby{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.Two = &TwoOneofs_SubMessage2{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOne(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOne + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomOneof) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomOneof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomOneof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 34: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Stringy", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Custom = &CustomOneof_Stringy{string(data[iNdEx:postIndex])} + iNdEx = postIndex + case 35: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CustomType", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var vv github_com_gogo_protobuf_test_custom.Uint128 + v := &vv + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.Custom = &CustomOneof_CustomType{*v} + iNdEx = postIndex + case 36: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CastType", wireType) + } + var v github_com_gogo_protobuf_test_casttype.MyUint64Type + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (github_com_gogo_protobuf_test_casttype.MyUint64Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Custom = &CustomOneof_CastType{v} + case 37: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyCustomName", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Custom = &CustomOneof_MyCustomName{v} + default: + iNdEx = preIndex + skippy, err := skipOne(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOne + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipOne(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOne + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOne + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOne + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthOne + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOne + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipOne(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthOne = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowOne = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unmarshaler/one.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unmarshaler/one.proto new file mode 100644 index 0000000000000000000000000000000000000000..aa2637f50b0ed2a55977d2ca93bd8e2e4bb01efc --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unmarshaler/one.proto @@ -0,0 +1,101 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package one; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Subby { + optional string sub = 1; +} + +message AllTypesOneOf { + oneof test_oneof { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + int64 Field4 = 4; + uint32 Field5 = 5; + uint64 Field6 = 6; + sint32 Field7 = 7; + sint64 Field8 = 8; + fixed32 Field9 = 9; + sfixed32 Field10 = 10; + fixed64 Field11 = 11; + sfixed64 Field12 = 12; + bool Field13 = 13; + string Field14 = 14; + bytes Field15 = 15; + Subby sub_message = 16; + } +} + +message TwoOneofs { + oneof one { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + } + + oneof two { + string Field34 = 34; + bytes Field35 = 35; + Subby sub_message2 = 36; + } +} + +message CustomOneof { + oneof custom { + string Stringy = 34; + bytes CustomType = 35 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; + uint64 CastType = 36 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + int64 CustomName = 37 [(gogoproto.customname) = "MyCustomName"]; + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unmarshaler/onepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unmarshaler/onepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..fdb4f2747d4ccceb40898f7a3b487acc52139cf0 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unmarshaler/onepb_test.go @@ -0,0 +1,632 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unmarshaler/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/unmarshaler/one.proto + +It has these top-level messages: + Subby + AllTypesOneOf + TwoOneofs + CustomOneof +*/ +package one + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestSubbyProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAllTypesOneOfProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestTwoOneofsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomOneofProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSubbyJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllTypesOneOfJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTwoOneofsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomOneofJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSubbyProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOneDescription(t *testing.T) { + OneDescription() +} +func TestSubbyVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllTypesOneOfVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTwoOneofsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomOneofVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSubbyGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllTypesOneOfGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTwoOneofsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomOneofGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSubbySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestAllTypesOneOfSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestTwoOneofsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestCustomOneofSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSubbyStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllTypesOneOfStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTwoOneofsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomOneofStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeboth/one.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeboth/one.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..12992d769fa196ee70da1ec512046be4e06d5008 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeboth/one.pb.go @@ -0,0 +1,6597 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeboth/one.proto +// DO NOT EDIT! + +/* + Package one is a generated protocol buffer package. + + It is generated from these files: + combos/unsafeboth/one.proto + + It has these top-level messages: + Subby + AllTypesOneOf + TwoOneofs + CustomOneof +*/ +package one + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_custom "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom" +import github_com_gogo_protobuf_test_casttype "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import unsafe "unsafe" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Subby struct { + Sub *string `protobuf:"bytes,1,opt,name=sub" json:"sub,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Subby) Reset() { *m = Subby{} } +func (*Subby) ProtoMessage() {} + +type AllTypesOneOf struct { + // Types that are valid to be assigned to TestOneof: + // *AllTypesOneOf_Field1 + // *AllTypesOneOf_Field2 + // *AllTypesOneOf_Field3 + // *AllTypesOneOf_Field4 + // *AllTypesOneOf_Field5 + // *AllTypesOneOf_Field6 + // *AllTypesOneOf_Field7 + // *AllTypesOneOf_Field8 + // *AllTypesOneOf_Field9 + // *AllTypesOneOf_Field10 + // *AllTypesOneOf_Field11 + // *AllTypesOneOf_Field12 + // *AllTypesOneOf_Field13 + // *AllTypesOneOf_Field14 + // *AllTypesOneOf_Field15 + // *AllTypesOneOf_SubMessage + TestOneof isAllTypesOneOf_TestOneof `protobuf_oneof:"test_oneof"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllTypesOneOf) Reset() { *m = AllTypesOneOf{} } +func (*AllTypesOneOf) ProtoMessage() {} + +type isAllTypesOneOf_TestOneof interface { + isAllTypesOneOf_TestOneof() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} + +type AllTypesOneOf_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,oneof"` +} +type AllTypesOneOf_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,oneof"` +} +type AllTypesOneOf_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,oneof"` +} +type AllTypesOneOf_Field4 struct { + Field4 int64 `protobuf:"varint,4,opt,name=Field4,oneof"` +} +type AllTypesOneOf_Field5 struct { + Field5 uint32 `protobuf:"varint,5,opt,name=Field5,oneof"` +} +type AllTypesOneOf_Field6 struct { + Field6 uint64 `protobuf:"varint,6,opt,name=Field6,oneof"` +} +type AllTypesOneOf_Field7 struct { + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7,oneof"` +} +type AllTypesOneOf_Field8 struct { + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8,oneof"` +} +type AllTypesOneOf_Field9 struct { + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9,oneof"` +} +type AllTypesOneOf_Field10 struct { + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10,oneof"` +} +type AllTypesOneOf_Field11 struct { + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11,oneof"` +} +type AllTypesOneOf_Field12 struct { + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12,oneof"` +} +type AllTypesOneOf_Field13 struct { + Field13 bool `protobuf:"varint,13,opt,name=Field13,oneof"` +} +type AllTypesOneOf_Field14 struct { + Field14 string `protobuf:"bytes,14,opt,name=Field14,oneof"` +} +type AllTypesOneOf_Field15 struct { + Field15 []byte `protobuf:"bytes,15,opt,name=Field15,oneof"` +} +type AllTypesOneOf_SubMessage struct { + SubMessage *Subby `protobuf:"bytes,16,opt,name=sub_message,oneof"` +} + +func (*AllTypesOneOf_Field1) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field2) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field3) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field4) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field5) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field6) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field7) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field8) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field9) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field10) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field11) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field12) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field13) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field14) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field15) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_SubMessage) isAllTypesOneOf_TestOneof() {} + +func (m *AllTypesOneOf) GetTestOneof() isAllTypesOneOf_TestOneof { + if m != nil { + return m.TestOneof + } + return nil +} + +func (m *AllTypesOneOf) GetField1() float64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *AllTypesOneOf) GetField2() float32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *AllTypesOneOf) GetField3() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *AllTypesOneOf) GetField4() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field4); ok { + return x.Field4 + } + return 0 +} + +func (m *AllTypesOneOf) GetField5() uint32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field5); ok { + return x.Field5 + } + return 0 +} + +func (m *AllTypesOneOf) GetField6() uint64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field6); ok { + return x.Field6 + } + return 0 +} + +func (m *AllTypesOneOf) GetField7() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field7); ok { + return x.Field7 + } + return 0 +} + +func (m *AllTypesOneOf) GetField8() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field8); ok { + return x.Field8 + } + return 0 +} + +func (m *AllTypesOneOf) GetField9() uint32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field9); ok { + return x.Field9 + } + return 0 +} + +func (m *AllTypesOneOf) GetField10() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field10); ok { + return x.Field10 + } + return 0 +} + +func (m *AllTypesOneOf) GetField11() uint64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field11); ok { + return x.Field11 + } + return 0 +} + +func (m *AllTypesOneOf) GetField12() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field12); ok { + return x.Field12 + } + return 0 +} + +func (m *AllTypesOneOf) GetField13() bool { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field13); ok { + return x.Field13 + } + return false +} + +func (m *AllTypesOneOf) GetField14() string { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field14); ok { + return x.Field14 + } + return "" +} + +func (m *AllTypesOneOf) GetField15() []byte { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field15); ok { + return x.Field15 + } + return nil +} + +func (m *AllTypesOneOf) GetSubMessage() *Subby { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_SubMessage); ok { + return x.SubMessage + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*AllTypesOneOf) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _AllTypesOneOf_OneofMarshaler, _AllTypesOneOf_OneofUnmarshaler, []interface{}{ + (*AllTypesOneOf_Field1)(nil), + (*AllTypesOneOf_Field2)(nil), + (*AllTypesOneOf_Field3)(nil), + (*AllTypesOneOf_Field4)(nil), + (*AllTypesOneOf_Field5)(nil), + (*AllTypesOneOf_Field6)(nil), + (*AllTypesOneOf_Field7)(nil), + (*AllTypesOneOf_Field8)(nil), + (*AllTypesOneOf_Field9)(nil), + (*AllTypesOneOf_Field10)(nil), + (*AllTypesOneOf_Field11)(nil), + (*AllTypesOneOf_Field12)(nil), + (*AllTypesOneOf_Field13)(nil), + (*AllTypesOneOf_Field14)(nil), + (*AllTypesOneOf_Field15)(nil), + (*AllTypesOneOf_SubMessage)(nil), + } +} + +func _AllTypesOneOf_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*AllTypesOneOf) + // test_oneof + switch x := m.TestOneof.(type) { + case *AllTypesOneOf_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *AllTypesOneOf_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *AllTypesOneOf_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case *AllTypesOneOf_Field4: + _ = b.EncodeVarint(4<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field4)) + case *AllTypesOneOf_Field5: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field5)) + case *AllTypesOneOf_Field6: + _ = b.EncodeVarint(6<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field6)) + case *AllTypesOneOf_Field7: + _ = b.EncodeVarint(7<<3 | proto.WireVarint) + _ = b.EncodeZigzag32(uint64(x.Field7)) + case *AllTypesOneOf_Field8: + _ = b.EncodeVarint(8<<3 | proto.WireVarint) + _ = b.EncodeZigzag64(uint64(x.Field8)) + case *AllTypesOneOf_Field9: + _ = b.EncodeVarint(9<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field9)) + case *AllTypesOneOf_Field10: + _ = b.EncodeVarint(10<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field10)) + case *AllTypesOneOf_Field11: + _ = b.EncodeVarint(11<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field11)) + case *AllTypesOneOf_Field12: + _ = b.EncodeVarint(12<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field12)) + case *AllTypesOneOf_Field13: + t := uint64(0) + if x.Field13 { + t = 1 + } + _ = b.EncodeVarint(13<<3 | proto.WireVarint) + _ = b.EncodeVarint(t) + case *AllTypesOneOf_Field14: + _ = b.EncodeVarint(14<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field14) + case *AllTypesOneOf_Field15: + _ = b.EncodeVarint(15<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field15) + case *AllTypesOneOf_SubMessage: + _ = b.EncodeVarint(16<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("AllTypesOneOf.TestOneof has unexpected type %T", x) + } + return nil +} + +func _AllTypesOneOf_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*AllTypesOneOf) + switch tag { + case 1: // test_oneof.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field1{math.Float64frombits(x)} + return true, err + case 2: // test_oneof.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // test_oneof.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field3{int32(x)} + return true, err + case 4: // test_oneof.Field4 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field4{int64(x)} + return true, err + case 5: // test_oneof.Field5 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field5{uint32(x)} + return true, err + case 6: // test_oneof.Field6 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field6{x} + return true, err + case 7: // test_oneof.Field7 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag32() + m.TestOneof = &AllTypesOneOf_Field7{int32(x)} + return true, err + case 8: // test_oneof.Field8 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag64() + m.TestOneof = &AllTypesOneOf_Field8{int64(x)} + return true, err + case 9: // test_oneof.Field9 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field9{uint32(x)} + return true, err + case 10: // test_oneof.Field10 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field10{int32(x)} + return true, err + case 11: // test_oneof.Field11 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field11{x} + return true, err + case 12: // test_oneof.Field12 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field12{int64(x)} + return true, err + case 13: // test_oneof.Field13 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field13{x != 0} + return true, err + case 14: // test_oneof.Field14 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.TestOneof = &AllTypesOneOf_Field14{x} + return true, err + case 15: // test_oneof.Field15 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.TestOneof = &AllTypesOneOf_Field15{x} + return true, err + case 16: // test_oneof.sub_message + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.TestOneof = &AllTypesOneOf_SubMessage{msg} + return true, err + default: + return false, nil + } +} + +type TwoOneofs struct { + // Types that are valid to be assigned to One: + // *TwoOneofs_Field1 + // *TwoOneofs_Field2 + // *TwoOneofs_Field3 + One isTwoOneofs_One `protobuf_oneof:"one"` + // Types that are valid to be assigned to Two: + // *TwoOneofs_Field34 + // *TwoOneofs_Field35 + // *TwoOneofs_SubMessage2 + Two isTwoOneofs_Two `protobuf_oneof:"two"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TwoOneofs) Reset() { *m = TwoOneofs{} } +func (*TwoOneofs) ProtoMessage() {} + +type isTwoOneofs_One interface { + isTwoOneofs_One() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} +type isTwoOneofs_Two interface { + isTwoOneofs_Two() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} + +type TwoOneofs_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,oneof"` +} +type TwoOneofs_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,oneof"` +} +type TwoOneofs_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,oneof"` +} +type TwoOneofs_Field34 struct { + Field34 string `protobuf:"bytes,34,opt,name=Field34,oneof"` +} +type TwoOneofs_Field35 struct { + Field35 []byte `protobuf:"bytes,35,opt,name=Field35,oneof"` +} +type TwoOneofs_SubMessage2 struct { + SubMessage2 *Subby `protobuf:"bytes,36,opt,name=sub_message2,oneof"` +} + +func (*TwoOneofs_Field1) isTwoOneofs_One() {} +func (*TwoOneofs_Field2) isTwoOneofs_One() {} +func (*TwoOneofs_Field3) isTwoOneofs_One() {} +func (*TwoOneofs_Field34) isTwoOneofs_Two() {} +func (*TwoOneofs_Field35) isTwoOneofs_Two() {} +func (*TwoOneofs_SubMessage2) isTwoOneofs_Two() {} + +func (m *TwoOneofs) GetOne() isTwoOneofs_One { + if m != nil { + return m.One + } + return nil +} +func (m *TwoOneofs) GetTwo() isTwoOneofs_Two { + if m != nil { + return m.Two + } + return nil +} + +func (m *TwoOneofs) GetField1() float64 { + if x, ok := m.GetOne().(*TwoOneofs_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *TwoOneofs) GetField2() float32 { + if x, ok := m.GetOne().(*TwoOneofs_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *TwoOneofs) GetField3() int32 { + if x, ok := m.GetOne().(*TwoOneofs_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *TwoOneofs) GetField34() string { + if x, ok := m.GetTwo().(*TwoOneofs_Field34); ok { + return x.Field34 + } + return "" +} + +func (m *TwoOneofs) GetField35() []byte { + if x, ok := m.GetTwo().(*TwoOneofs_Field35); ok { + return x.Field35 + } + return nil +} + +func (m *TwoOneofs) GetSubMessage2() *Subby { + if x, ok := m.GetTwo().(*TwoOneofs_SubMessage2); ok { + return x.SubMessage2 + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*TwoOneofs) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _TwoOneofs_OneofMarshaler, _TwoOneofs_OneofUnmarshaler, []interface{}{ + (*TwoOneofs_Field1)(nil), + (*TwoOneofs_Field2)(nil), + (*TwoOneofs_Field3)(nil), + (*TwoOneofs_Field34)(nil), + (*TwoOneofs_Field35)(nil), + (*TwoOneofs_SubMessage2)(nil), + } +} + +func _TwoOneofs_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*TwoOneofs) + // one + switch x := m.One.(type) { + case *TwoOneofs_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *TwoOneofs_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *TwoOneofs_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case nil: + default: + return fmt.Errorf("TwoOneofs.One has unexpected type %T", x) + } + // two + switch x := m.Two.(type) { + case *TwoOneofs_Field34: + _ = b.EncodeVarint(34<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field34) + case *TwoOneofs_Field35: + _ = b.EncodeVarint(35<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field35) + case *TwoOneofs_SubMessage2: + _ = b.EncodeVarint(36<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage2); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("TwoOneofs.Two has unexpected type %T", x) + } + return nil +} + +func _TwoOneofs_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*TwoOneofs) + switch tag { + case 1: // one.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.One = &TwoOneofs_Field1{math.Float64frombits(x)} + return true, err + case 2: // one.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.One = &TwoOneofs_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // one.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.One = &TwoOneofs_Field3{int32(x)} + return true, err + case 34: // two.Field34 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Two = &TwoOneofs_Field34{x} + return true, err + case 35: // two.Field35 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.Two = &TwoOneofs_Field35{x} + return true, err + case 36: // two.sub_message2 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.Two = &TwoOneofs_SubMessage2{msg} + return true, err + default: + return false, nil + } +} + +type CustomOneof struct { + // Types that are valid to be assigned to Custom: + // *CustomOneof_Stringy + // *CustomOneof_CustomType + // *CustomOneof_CastType + // *CustomOneof_MyCustomName + Custom isCustomOneof_Custom `protobuf_oneof:"custom"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomOneof) Reset() { *m = CustomOneof{} } +func (*CustomOneof) ProtoMessage() {} + +type isCustomOneof_Custom interface { + isCustomOneof_Custom() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} + +type CustomOneof_Stringy struct { + Stringy string `protobuf:"bytes,34,opt,name=Stringy,oneof"` +} +type CustomOneof_CustomType struct { + CustomType github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,35,opt,name=CustomType,oneof,customtype=github.com/gogo/protobuf/test/custom.Uint128"` +} +type CustomOneof_CastType struct { + CastType github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,36,opt,name=CastType,oneof,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type"` +} +type CustomOneof_MyCustomName struct { + MyCustomName int64 `protobuf:"varint,37,opt,name=CustomName,oneof"` +} + +func (*CustomOneof_Stringy) isCustomOneof_Custom() {} +func (*CustomOneof_CustomType) isCustomOneof_Custom() {} +func (*CustomOneof_CastType) isCustomOneof_Custom() {} +func (*CustomOneof_MyCustomName) isCustomOneof_Custom() {} + +func (m *CustomOneof) GetCustom() isCustomOneof_Custom { + if m != nil { + return m.Custom + } + return nil +} + +func (m *CustomOneof) GetStringy() string { + if x, ok := m.GetCustom().(*CustomOneof_Stringy); ok { + return x.Stringy + } + return "" +} + +func (m *CustomOneof) GetCastType() github_com_gogo_protobuf_test_casttype.MyUint64Type { + if x, ok := m.GetCustom().(*CustomOneof_CastType); ok { + return x.CastType + } + return 0 +} + +func (m *CustomOneof) GetMyCustomName() int64 { + if x, ok := m.GetCustom().(*CustomOneof_MyCustomName); ok { + return x.MyCustomName + } + return 0 +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*CustomOneof) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _CustomOneof_OneofMarshaler, _CustomOneof_OneofUnmarshaler, []interface{}{ + (*CustomOneof_Stringy)(nil), + (*CustomOneof_CustomType)(nil), + (*CustomOneof_CastType)(nil), + (*CustomOneof_MyCustomName)(nil), + } +} + +func _CustomOneof_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*CustomOneof) + // custom + switch x := m.Custom.(type) { + case *CustomOneof_Stringy: + _ = b.EncodeVarint(34<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Stringy) + case *CustomOneof_CustomType: + _ = b.EncodeVarint(35<<3 | proto.WireBytes) + data, err := x.CustomType.Marshal() + if err != nil { + return err + } + _ = b.EncodeRawBytes(data) + case *CustomOneof_CastType: + _ = b.EncodeVarint(36<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.CastType)) + case *CustomOneof_MyCustomName: + _ = b.EncodeVarint(37<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.MyCustomName)) + case nil: + default: + return fmt.Errorf("CustomOneof.Custom has unexpected type %T", x) + } + return nil +} + +func _CustomOneof_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*CustomOneof) + switch tag { + case 34: // custom.Stringy + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Custom = &CustomOneof_Stringy{x} + return true, err + case 35: // custom.CustomType + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + if err != nil { + return true, err + } + var cc github_com_gogo_protobuf_test_custom.Uint128 + c := &cc + err = c.Unmarshal(x) + m.Custom = &CustomOneof_CustomType{*c} + return true, err + case 36: // custom.CastType + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Custom = &CustomOneof_CastType{github_com_gogo_protobuf_test_casttype.MyUint64Type(x)} + return true, err + case 37: // custom.CustomName + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Custom = &CustomOneof_MyCustomName{int64(x)} + return true, err + default: + return false, nil + } +} + +func (this *Subby) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *AllTypesOneOf) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *TwoOneofs) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *CustomOneof) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func OneDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unsafeboth/one.proto"), + Package: func(v string) *string { return &v }("one"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Subby"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("sub"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("AllTypesOneOf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("sub_message"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(0), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("test_oneof")}}, + }, {Name: func(v string) *string { return &v }("TwoOneofs"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field34"), + Number: func(v int32) *int32 { return &v }(34), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("Field35"), + Number: func(v int32) *int32 { return &v }(35), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("sub_message2"), + Number: func(v int32) *int32 { return &v }(36), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(1), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("one")}, {Name: func(v string) *string { return &v }("two")}}, + }, {Name: func(v string) *string { return &v }("CustomOneof"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Stringy"), + Number: func(v int32) *int32 { return &v }(34), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CustomType"), + Number: func(v int32) *int32 { return &v }(35), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }, {Name: func(v string) *string { return &v }("CastType"), + Number: func(v int32) *int32 { return &v }(36), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("CustomName"), + Number: func(v int32) *int32 { return &v }(37), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0xc, 0x4d, 0x79, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4e, 0x61, 0x6d, 0x65})}}, + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("custom")}}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x1}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x1})}}, + }}, + } +} +func (this *Subby) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Subby) + if !ok { + return fmt.Errorf("that is not of type *Subby") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Subby but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Subbybut is not nil && this == nil") + } + if this.Sub != nil && that1.Sub != nil { + if *this.Sub != *that1.Sub { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", *this.Sub, *that1.Sub) + } + } else if this.Sub != nil { + return fmt.Errorf("this.Sub == nil && that.Sub != nil") + } else if that1.Sub != nil { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Subby) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Subby) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Sub != nil && that1.Sub != nil { + if *this.Sub != *that1.Sub { + return false + } + } else if this.Sub != nil { + return false + } else if that1.Sub != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllTypesOneOf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOfbut is not nil && this == nil") + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return fmt.Errorf("this.TestOneof != nil && that1.TestOneof == nil") + } + } else if this.TestOneof == nil { + return fmt.Errorf("this.TestOneof == nil && that1.TestOneof != nil") + } else if err := this.TestOneof.VerboseEqual(that1.TestOneof); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AllTypesOneOf_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field1) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *AllTypesOneOf_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field2) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *AllTypesOneOf_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field3) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *AllTypesOneOf_Field4) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field4) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field4") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field4 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field4but is not nil && this == nil") + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + return nil +} +func (this *AllTypesOneOf_Field5) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field5) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field5") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field5 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field5but is not nil && this == nil") + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + return nil +} +func (this *AllTypesOneOf_Field6) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field6) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field6") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field6 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field6but is not nil && this == nil") + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + return nil +} +func (this *AllTypesOneOf_Field7) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field7) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field7") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field7 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field7but is not nil && this == nil") + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + return nil +} +func (this *AllTypesOneOf_Field8) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field8) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field8") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field8 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field8but is not nil && this == nil") + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + return nil +} +func (this *AllTypesOneOf_Field9) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field9) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field9") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field9 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field9but is not nil && this == nil") + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + return nil +} +func (this *AllTypesOneOf_Field10) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field10) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field10") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field10 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field10but is not nil && this == nil") + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + return nil +} +func (this *AllTypesOneOf_Field11) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field11) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field11") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field11 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field11but is not nil && this == nil") + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + return nil +} +func (this *AllTypesOneOf_Field12) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field12) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field12") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field12 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field12but is not nil && this == nil") + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + return nil +} +func (this *AllTypesOneOf_Field13) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field13) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field13") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field13 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field13but is not nil && this == nil") + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + return nil +} +func (this *AllTypesOneOf_Field14) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field14) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field14") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field14 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field14but is not nil && this == nil") + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + return nil +} +func (this *AllTypesOneOf_Field15) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field15) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field15") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field15 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field15but is not nil && this == nil") + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + return nil +} +func (this *AllTypesOneOf_SubMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_SubMessage) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_SubMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_SubMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_SubMessagebut is not nil && this == nil") + } + if !this.SubMessage.Equal(that1.SubMessage) { + return fmt.Errorf("SubMessage this(%v) Not Equal that(%v)", this.SubMessage, that1.SubMessage) + } + return nil +} +func (this *AllTypesOneOf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return false + } + } else if this.TestOneof == nil { + return false + } else if !this.TestOneof.Equal(that1.TestOneof) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllTypesOneOf_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *AllTypesOneOf_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *AllTypesOneOf_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *AllTypesOneOf_Field4) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field4) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field4 != that1.Field4 { + return false + } + return true +} +func (this *AllTypesOneOf_Field5) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field5) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field5 != that1.Field5 { + return false + } + return true +} +func (this *AllTypesOneOf_Field6) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field6) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field6 != that1.Field6 { + return false + } + return true +} +func (this *AllTypesOneOf_Field7) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field7) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field7 != that1.Field7 { + return false + } + return true +} +func (this *AllTypesOneOf_Field8) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field8) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field8 != that1.Field8 { + return false + } + return true +} +func (this *AllTypesOneOf_Field9) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field9) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field9 != that1.Field9 { + return false + } + return true +} +func (this *AllTypesOneOf_Field10) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field10) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field10 != that1.Field10 { + return false + } + return true +} +func (this *AllTypesOneOf_Field11) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field11) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field11 != that1.Field11 { + return false + } + return true +} +func (this *AllTypesOneOf_Field12) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field12) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field12 != that1.Field12 { + return false + } + return true +} +func (this *AllTypesOneOf_Field13) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field13) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field13 != that1.Field13 { + return false + } + return true +} +func (this *AllTypesOneOf_Field14) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field14) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field14 != that1.Field14 { + return false + } + return true +} +func (this *AllTypesOneOf_Field15) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field15) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + return true +} +func (this *AllTypesOneOf_SubMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_SubMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage.Equal(that1.SubMessage) { + return false + } + return true +} +func (this *TwoOneofs) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofsbut is not nil && this == nil") + } + if that1.One == nil { + if this.One != nil { + return fmt.Errorf("this.One != nil && that1.One == nil") + } + } else if this.One == nil { + return fmt.Errorf("this.One == nil && that1.One != nil") + } else if err := this.One.VerboseEqual(that1.One); err != nil { + return err + } + if that1.Two == nil { + if this.Two != nil { + return fmt.Errorf("this.Two != nil && that1.Two == nil") + } + } else if this.Two == nil { + return fmt.Errorf("this.Two == nil && that1.Two != nil") + } else if err := this.Two.VerboseEqual(that1.Two); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *TwoOneofs_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field1) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *TwoOneofs_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field2) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *TwoOneofs_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field3) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *TwoOneofs_Field34) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field34) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field34") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field34 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field34but is not nil && this == nil") + } + if this.Field34 != that1.Field34 { + return fmt.Errorf("Field34 this(%v) Not Equal that(%v)", this.Field34, that1.Field34) + } + return nil +} +func (this *TwoOneofs_Field35) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field35) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field35") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field35 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field35but is not nil && this == nil") + } + if !bytes.Equal(this.Field35, that1.Field35) { + return fmt.Errorf("Field35 this(%v) Not Equal that(%v)", this.Field35, that1.Field35) + } + return nil +} +func (this *TwoOneofs_SubMessage2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_SubMessage2) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_SubMessage2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_SubMessage2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_SubMessage2but is not nil && this == nil") + } + if !this.SubMessage2.Equal(that1.SubMessage2) { + return fmt.Errorf("SubMessage2 this(%v) Not Equal that(%v)", this.SubMessage2, that1.SubMessage2) + } + return nil +} +func (this *TwoOneofs) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.One == nil { + if this.One != nil { + return false + } + } else if this.One == nil { + return false + } else if !this.One.Equal(that1.One) { + return false + } + if that1.Two == nil { + if this.Two != nil { + return false + } + } else if this.Two == nil { + return false + } else if !this.Two.Equal(that1.Two) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *TwoOneofs_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *TwoOneofs_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *TwoOneofs_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *TwoOneofs_Field34) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field34) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field34 != that1.Field34 { + return false + } + return true +} +func (this *TwoOneofs_Field35) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field35) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field35, that1.Field35) { + return false + } + return true +} +func (this *TwoOneofs_SubMessage2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_SubMessage2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage2.Equal(that1.SubMessage2) { + return false + } + return true +} +func (this *CustomOneof) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneofbut is not nil && this == nil") + } + if that1.Custom == nil { + if this.Custom != nil { + return fmt.Errorf("this.Custom != nil && that1.Custom == nil") + } + } else if this.Custom == nil { + return fmt.Errorf("this.Custom == nil && that1.Custom != nil") + } else if err := this.Custom.VerboseEqual(that1.Custom); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomOneof_Stringy) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_Stringy) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_Stringy") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_Stringy but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_Stringybut is not nil && this == nil") + } + if this.Stringy != that1.Stringy { + return fmt.Errorf("Stringy this(%v) Not Equal that(%v)", this.Stringy, that1.Stringy) + } + return nil +} +func (this *CustomOneof_CustomType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_CustomType) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_CustomType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_CustomType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_CustomTypebut is not nil && this == nil") + } + if !this.CustomType.Equal(that1.CustomType) { + return fmt.Errorf("CustomType this(%v) Not Equal that(%v)", this.CustomType, that1.CustomType) + } + return nil +} +func (this *CustomOneof_CastType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_CastType) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_CastType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_CastType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_CastTypebut is not nil && this == nil") + } + if this.CastType != that1.CastType { + return fmt.Errorf("CastType this(%v) Not Equal that(%v)", this.CastType, that1.CastType) + } + return nil +} +func (this *CustomOneof_MyCustomName) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_MyCustomName) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_MyCustomName") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_MyCustomName but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_MyCustomNamebut is not nil && this == nil") + } + if this.MyCustomName != that1.MyCustomName { + return fmt.Errorf("MyCustomName this(%v) Not Equal that(%v)", this.MyCustomName, that1.MyCustomName) + } + return nil +} +func (this *CustomOneof) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Custom == nil { + if this.Custom != nil { + return false + } + } else if this.Custom == nil { + return false + } else if !this.Custom.Equal(that1.Custom) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomOneof_Stringy) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_Stringy) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Stringy != that1.Stringy { + return false + } + return true +} +func (this *CustomOneof_CustomType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_CustomType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.CustomType.Equal(that1.CustomType) { + return false + } + return true +} +func (this *CustomOneof_CastType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_CastType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.CastType != that1.CastType { + return false + } + return true +} +func (this *CustomOneof_MyCustomName) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_MyCustomName) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.MyCustomName != that1.MyCustomName { + return false + } + return true +} +func (this *Subby) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&one.Subby{") + if this.Sub != nil { + s = append(s, "Sub: "+valueToGoStringOne(this.Sub, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllTypesOneOf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 20) + s = append(s, "&one.AllTypesOneOf{") + if this.TestOneof != nil { + s = append(s, "TestOneof: "+fmt.Sprintf("%#v", this.TestOneof)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllTypesOneOf_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field4) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field4{` + + `Field4:` + fmt.Sprintf("%#v", this.Field4) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field5) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field5{` + + `Field5:` + fmt.Sprintf("%#v", this.Field5) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field6) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field6{` + + `Field6:` + fmt.Sprintf("%#v", this.Field6) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field7) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field7{` + + `Field7:` + fmt.Sprintf("%#v", this.Field7) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field8) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field8{` + + `Field8:` + fmt.Sprintf("%#v", this.Field8) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field9) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field9{` + + `Field9:` + fmt.Sprintf("%#v", this.Field9) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field10) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field10{` + + `Field10:` + fmt.Sprintf("%#v", this.Field10) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field11) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field11{` + + `Field11:` + fmt.Sprintf("%#v", this.Field11) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field12) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field12{` + + `Field12:` + fmt.Sprintf("%#v", this.Field12) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field13) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field13{` + + `Field13:` + fmt.Sprintf("%#v", this.Field13) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field14) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field14{` + + `Field14:` + fmt.Sprintf("%#v", this.Field14) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field15) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field15{` + + `Field15:` + fmt.Sprintf("%#v", this.Field15) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_SubMessage) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_SubMessage{` + + `SubMessage:` + fmt.Sprintf("%#v", this.SubMessage) + `}`}, ", ") + return s +} +func (this *TwoOneofs) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 10) + s = append(s, "&one.TwoOneofs{") + if this.One != nil { + s = append(s, "One: "+fmt.Sprintf("%#v", this.One)+",\n") + } + if this.Two != nil { + s = append(s, "Two: "+fmt.Sprintf("%#v", this.Two)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *TwoOneofs_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field34) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field34{` + + `Field34:` + fmt.Sprintf("%#v", this.Field34) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field35) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field35{` + + `Field35:` + fmt.Sprintf("%#v", this.Field35) + `}`}, ", ") + return s +} +func (this *TwoOneofs_SubMessage2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_SubMessage2{` + + `SubMessage2:` + fmt.Sprintf("%#v", this.SubMessage2) + `}`}, ", ") + return s +} +func (this *CustomOneof) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&one.CustomOneof{") + if this.Custom != nil { + s = append(s, "Custom: "+fmt.Sprintf("%#v", this.Custom)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomOneof_Stringy) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_Stringy{` + + `Stringy:` + fmt.Sprintf("%#v", this.Stringy) + `}`}, ", ") + return s +} +func (this *CustomOneof_CustomType) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_CustomType{` + + `CustomType:` + fmt.Sprintf("%#v", this.CustomType) + `}`}, ", ") + return s +} +func (this *CustomOneof_CastType) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_CastType{` + + `CastType:` + fmt.Sprintf("%#v", this.CastType) + `}`}, ", ") + return s +} +func (this *CustomOneof_MyCustomName) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_MyCustomName{` + + `MyCustomName:` + fmt.Sprintf("%#v", this.MyCustomName) + `}`}, ", ") + return s +} +func valueToGoStringOne(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringOne(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedSubby(r randyOne, easy bool) *Subby { + this := &Subby{} + if r.Intn(10) != 0 { + v1 := randStringOne(r) + this.Sub = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 2) + } + return this +} + +func NewPopulatedAllTypesOneOf(r randyOne, easy bool) *AllTypesOneOf { + this := &AllTypesOneOf{} + oneofNumber_TestOneof := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}[r.Intn(16)] + switch oneofNumber_TestOneof { + case 1: + this.TestOneof = NewPopulatedAllTypesOneOf_Field1(r, easy) + case 2: + this.TestOneof = NewPopulatedAllTypesOneOf_Field2(r, easy) + case 3: + this.TestOneof = NewPopulatedAllTypesOneOf_Field3(r, easy) + case 4: + this.TestOneof = NewPopulatedAllTypesOneOf_Field4(r, easy) + case 5: + this.TestOneof = NewPopulatedAllTypesOneOf_Field5(r, easy) + case 6: + this.TestOneof = NewPopulatedAllTypesOneOf_Field6(r, easy) + case 7: + this.TestOneof = NewPopulatedAllTypesOneOf_Field7(r, easy) + case 8: + this.TestOneof = NewPopulatedAllTypesOneOf_Field8(r, easy) + case 9: + this.TestOneof = NewPopulatedAllTypesOneOf_Field9(r, easy) + case 10: + this.TestOneof = NewPopulatedAllTypesOneOf_Field10(r, easy) + case 11: + this.TestOneof = NewPopulatedAllTypesOneOf_Field11(r, easy) + case 12: + this.TestOneof = NewPopulatedAllTypesOneOf_Field12(r, easy) + case 13: + this.TestOneof = NewPopulatedAllTypesOneOf_Field13(r, easy) + case 14: + this.TestOneof = NewPopulatedAllTypesOneOf_Field14(r, easy) + case 15: + this.TestOneof = NewPopulatedAllTypesOneOf_Field15(r, easy) + case 16: + this.TestOneof = NewPopulatedAllTypesOneOf_SubMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 17) + } + return this +} + +func NewPopulatedAllTypesOneOf_Field1(r randyOne, easy bool) *AllTypesOneOf_Field1 { + this := &AllTypesOneOf_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field2(r randyOne, easy bool) *AllTypesOneOf_Field2 { + this := &AllTypesOneOf_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field3(r randyOne, easy bool) *AllTypesOneOf_Field3 { + this := &AllTypesOneOf_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field4(r randyOne, easy bool) *AllTypesOneOf_Field4 { + this := &AllTypesOneOf_Field4{} + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field5(r randyOne, easy bool) *AllTypesOneOf_Field5 { + this := &AllTypesOneOf_Field5{} + this.Field5 = uint32(r.Uint32()) + return this +} +func NewPopulatedAllTypesOneOf_Field6(r randyOne, easy bool) *AllTypesOneOf_Field6 { + this := &AllTypesOneOf_Field6{} + this.Field6 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedAllTypesOneOf_Field7(r randyOne, easy bool) *AllTypesOneOf_Field7 { + this := &AllTypesOneOf_Field7{} + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field8(r randyOne, easy bool) *AllTypesOneOf_Field8 { + this := &AllTypesOneOf_Field8{} + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field9(r randyOne, easy bool) *AllTypesOneOf_Field9 { + this := &AllTypesOneOf_Field9{} + this.Field9 = uint32(r.Uint32()) + return this +} +func NewPopulatedAllTypesOneOf_Field10(r randyOne, easy bool) *AllTypesOneOf_Field10 { + this := &AllTypesOneOf_Field10{} + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field11(r randyOne, easy bool) *AllTypesOneOf_Field11 { + this := &AllTypesOneOf_Field11{} + this.Field11 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedAllTypesOneOf_Field12(r randyOne, easy bool) *AllTypesOneOf_Field12 { + this := &AllTypesOneOf_Field12{} + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field13(r randyOne, easy bool) *AllTypesOneOf_Field13 { + this := &AllTypesOneOf_Field13{} + this.Field13 = bool(bool(r.Intn(2) == 0)) + return this +} +func NewPopulatedAllTypesOneOf_Field14(r randyOne, easy bool) *AllTypesOneOf_Field14 { + this := &AllTypesOneOf_Field14{} + this.Field14 = randStringOne(r) + return this +} +func NewPopulatedAllTypesOneOf_Field15(r randyOne, easy bool) *AllTypesOneOf_Field15 { + this := &AllTypesOneOf_Field15{} + v2 := r.Intn(100) + this.Field15 = make([]byte, v2) + for i := 0; i < v2; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedAllTypesOneOf_SubMessage(r randyOne, easy bool) *AllTypesOneOf_SubMessage { + this := &AllTypesOneOf_SubMessage{} + this.SubMessage = NewPopulatedSubby(r, easy) + return this +} +func NewPopulatedTwoOneofs(r randyOne, easy bool) *TwoOneofs { + this := &TwoOneofs{} + oneofNumber_One := []int32{1, 2, 3}[r.Intn(3)] + switch oneofNumber_One { + case 1: + this.One = NewPopulatedTwoOneofs_Field1(r, easy) + case 2: + this.One = NewPopulatedTwoOneofs_Field2(r, easy) + case 3: + this.One = NewPopulatedTwoOneofs_Field3(r, easy) + } + oneofNumber_Two := []int32{34, 35, 36}[r.Intn(3)] + switch oneofNumber_Two { + case 34: + this.Two = NewPopulatedTwoOneofs_Field34(r, easy) + case 35: + this.Two = NewPopulatedTwoOneofs_Field35(r, easy) + case 36: + this.Two = NewPopulatedTwoOneofs_SubMessage2(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 37) + } + return this +} + +func NewPopulatedTwoOneofs_Field1(r randyOne, easy bool) *TwoOneofs_Field1 { + this := &TwoOneofs_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field2(r randyOne, easy bool) *TwoOneofs_Field2 { + this := &TwoOneofs_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field3(r randyOne, easy bool) *TwoOneofs_Field3 { + this := &TwoOneofs_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field34(r randyOne, easy bool) *TwoOneofs_Field34 { + this := &TwoOneofs_Field34{} + this.Field34 = randStringOne(r) + return this +} +func NewPopulatedTwoOneofs_Field35(r randyOne, easy bool) *TwoOneofs_Field35 { + this := &TwoOneofs_Field35{} + v3 := r.Intn(100) + this.Field35 = make([]byte, v3) + for i := 0; i < v3; i++ { + this.Field35[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedTwoOneofs_SubMessage2(r randyOne, easy bool) *TwoOneofs_SubMessage2 { + this := &TwoOneofs_SubMessage2{} + this.SubMessage2 = NewPopulatedSubby(r, easy) + return this +} +func NewPopulatedCustomOneof(r randyOne, easy bool) *CustomOneof { + this := &CustomOneof{} + oneofNumber_Custom := []int32{34, 35, 36, 37}[r.Intn(4)] + switch oneofNumber_Custom { + case 34: + this.Custom = NewPopulatedCustomOneof_Stringy(r, easy) + case 35: + this.Custom = NewPopulatedCustomOneof_CustomType(r, easy) + case 36: + this.Custom = NewPopulatedCustomOneof_CastType(r, easy) + case 37: + this.Custom = NewPopulatedCustomOneof_MyCustomName(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 38) + } + return this +} + +func NewPopulatedCustomOneof_Stringy(r randyOne, easy bool) *CustomOneof_Stringy { + this := &CustomOneof_Stringy{} + this.Stringy = randStringOne(r) + return this +} +func NewPopulatedCustomOneof_CustomType(r randyOne, easy bool) *CustomOneof_CustomType { + this := &CustomOneof_CustomType{} + v4 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.CustomType = *v4 + return this +} +func NewPopulatedCustomOneof_CastType(r randyOne, easy bool) *CustomOneof_CastType { + this := &CustomOneof_CastType{} + this.CastType = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + return this +} +func NewPopulatedCustomOneof_MyCustomName(r randyOne, easy bool) *CustomOneof_MyCustomName { + this := &CustomOneof_MyCustomName{} + this.MyCustomName = int64(r.Int63()) + if r.Intn(2) == 0 { + this.MyCustomName *= -1 + } + return this +} + +type randyOne interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneOne(r randyOne) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringOne(r randyOne) string { + v5 := r.Intn(100) + tmps := make([]rune, v5) + for i := 0; i < v5; i++ { + tmps[i] = randUTF8RuneOne(r) + } + return string(tmps) +} +func randUnrecognizedOne(r randyOne, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldOne(data, r, fieldNumber, wire) + } + return data +} +func randFieldOne(data []byte, r randyOne, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateOne(data, uint64(key)) + v6 := r.Int63() + if r.Intn(2) == 0 { + v6 *= -1 + } + data = encodeVarintPopulateOne(data, uint64(v6)) + case 1: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateOne(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateOne(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateOne(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Subby) Size() (n int) { + var l int + _ = l + if m.Sub != nil { + l = len(*m.Sub) + n += 1 + l + sovOne(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllTypesOneOf) Size() (n int) { + var l int + _ = l + if m.TestOneof != nil { + n += m.TestOneof.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllTypesOneOf_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *AllTypesOneOf_Field4) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field4)) + return n +} +func (m *AllTypesOneOf_Field5) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field5)) + return n +} +func (m *AllTypesOneOf_Field6) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field6)) + return n +} +func (m *AllTypesOneOf_Field7) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field7)) + return n +} +func (m *AllTypesOneOf_Field8) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field8)) + return n +} +func (m *AllTypesOneOf_Field9) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field10) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field11) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field12) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field13) Size() (n int) { + var l int + _ = l + n += 2 + return n +} +func (m *AllTypesOneOf_Field14) Size() (n int) { + var l int + _ = l + l = len(m.Field14) + n += 1 + l + sovOne(uint64(l)) + return n +} +func (m *AllTypesOneOf_Field15) Size() (n int) { + var l int + _ = l + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovOne(uint64(l)) + } + return n +} +func (m *AllTypesOneOf_SubMessage) Size() (n int) { + var l int + _ = l + if m.SubMessage != nil { + l = m.SubMessage.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *TwoOneofs) Size() (n int) { + var l int + _ = l + if m.One != nil { + n += m.One.Size() + } + if m.Two != nil { + n += m.Two.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TwoOneofs_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *TwoOneofs_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *TwoOneofs_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *TwoOneofs_Field34) Size() (n int) { + var l int + _ = l + l = len(m.Field34) + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *TwoOneofs_Field35) Size() (n int) { + var l int + _ = l + if m.Field35 != nil { + l = len(m.Field35) + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *TwoOneofs_SubMessage2) Size() (n int) { + var l int + _ = l + if m.SubMessage2 != nil { + l = m.SubMessage2.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *CustomOneof) Size() (n int) { + var l int + _ = l + if m.Custom != nil { + n += m.Custom.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomOneof_Stringy) Size() (n int) { + var l int + _ = l + l = len(m.Stringy) + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *CustomOneof_CustomType) Size() (n int) { + var l int + _ = l + l = m.CustomType.Size() + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *CustomOneof_CastType) Size() (n int) { + var l int + _ = l + n += 2 + sovOne(uint64(m.CastType)) + return n +} +func (m *CustomOneof_MyCustomName) Size() (n int) { + var l int + _ = l + n += 2 + sovOne(uint64(m.MyCustomName)) + return n +} + +func sovOne(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozOne(x uint64) (n int) { + return sovOne(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Subby) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Subby{`, + `Sub:` + valueToStringOne(this.Sub) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf{`, + `TestOneof:` + fmt.Sprintf("%v", this.TestOneof) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field4) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field4{`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field5) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field5{`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field6) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field6{`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field7) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field7{`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field8) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field8{`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field9) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field9{`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field10) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field10{`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field11) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field11{`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field12) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field12{`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field13) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field13{`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field14) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field14{`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field15) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field15{`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_SubMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_SubMessage{`, + `SubMessage:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs{`, + `One:` + fmt.Sprintf("%v", this.One) + `,`, + `Two:` + fmt.Sprintf("%v", this.Two) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field34) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field34{`, + `Field34:` + fmt.Sprintf("%v", this.Field34) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field35) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field35{`, + `Field35:` + fmt.Sprintf("%v", this.Field35) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_SubMessage2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_SubMessage2{`, + `SubMessage2:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage2), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof{`, + `Custom:` + fmt.Sprintf("%v", this.Custom) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_Stringy) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_Stringy{`, + `Stringy:` + fmt.Sprintf("%v", this.Stringy) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_CustomType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_CustomType{`, + `CustomType:` + fmt.Sprintf("%v", this.CustomType) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_CastType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_CastType{`, + `CastType:` + fmt.Sprintf("%v", this.CastType) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_MyCustomName) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_MyCustomName{`, + `MyCustomName:` + fmt.Sprintf("%v", this.MyCustomName) + `,`, + `}`, + }, "") + return s +} +func valueToStringOne(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Subby) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Subby) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Sub != nil { + data[i] = 0xa + i++ + i = encodeVarintOne(data, i, uint64(len(*m.Sub))) + i += copy(data[i:], *m.Sub) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AllTypesOneOf) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AllTypesOneOf) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.TestOneof != nil { + nn1, err := m.TestOneof.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn1 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AllTypesOneOf_Field1) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = m.Field1 + i += 8 + return i, nil +} +func (m *AllTypesOneOf_Field2) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = m.Field2 + i += 4 + return i, nil +} +func (m *AllTypesOneOf_Field3) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x18 + i++ + i = encodeVarintOne(data, i, uint64(m.Field3)) + return i, nil +} +func (m *AllTypesOneOf_Field4) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x20 + i++ + i = encodeVarintOne(data, i, uint64(m.Field4)) + return i, nil +} +func (m *AllTypesOneOf_Field5) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x28 + i++ + i = encodeVarintOne(data, i, uint64(m.Field5)) + return i, nil +} +func (m *AllTypesOneOf_Field6) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x30 + i++ + i = encodeVarintOne(data, i, uint64(m.Field6)) + return i, nil +} +func (m *AllTypesOneOf_Field7) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x38 + i++ + i = encodeVarintOne(data, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31)))) + return i, nil +} +func (m *AllTypesOneOf_Field8) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x40 + i++ + i = encodeVarintOne(data, i, uint64((uint64(m.Field8)<<1)^uint64((m.Field8>>63)))) + return i, nil +} +func (m *AllTypesOneOf_Field9) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = m.Field9 + i += 4 + return i, nil +} +func (m *AllTypesOneOf_Field10) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = m.Field10 + i += 4 + return i, nil +} +func (m *AllTypesOneOf_Field11) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = m.Field11 + i += 8 + return i, nil +} +func (m *AllTypesOneOf_Field12) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = m.Field12 + i += 8 + return i, nil +} +func (m *AllTypesOneOf_Field13) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x68 + i++ + if m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + return i, nil +} +func (m *AllTypesOneOf_Field14) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x72 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field14))) + i += copy(data[i:], m.Field14) + return i, nil +} +func (m *AllTypesOneOf_Field15) MarshalTo(data []byte) (int, error) { + i := 0 + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + return i, nil +} +func (m *AllTypesOneOf_SubMessage) MarshalTo(data []byte) (int, error) { + i := 0 + if m.SubMessage != nil { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + i = encodeVarintOne(data, i, uint64(m.SubMessage.Size())) + n2, err := m.SubMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + } + return i, nil +} +func (m *TwoOneofs) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *TwoOneofs) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.One != nil { + nn3, err := m.One.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn3 + } + if m.Two != nil { + nn4, err := m.Two.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn4 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TwoOneofs_Field1) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = m.Field1 + i += 8 + return i, nil +} +func (m *TwoOneofs_Field2) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = m.Field2 + i += 4 + return i, nil +} +func (m *TwoOneofs_Field3) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x18 + i++ + i = encodeVarintOne(data, i, uint64(m.Field3)) + return i, nil +} +func (m *TwoOneofs_Field34) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x92 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field34))) + i += copy(data[i:], m.Field34) + return i, nil +} +func (m *TwoOneofs_Field35) MarshalTo(data []byte) (int, error) { + i := 0 + if m.Field35 != nil { + data[i] = 0x9a + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field35))) + i += copy(data[i:], m.Field35) + } + return i, nil +} +func (m *TwoOneofs_SubMessage2) MarshalTo(data []byte) (int, error) { + i := 0 + if m.SubMessage2 != nil { + data[i] = 0xa2 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(m.SubMessage2.Size())) + n5, err := m.SubMessage2.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n5 + } + return i, nil +} +func (m *CustomOneof) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomOneof) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Custom != nil { + nn6, err := m.Custom.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn6 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomOneof_Stringy) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x92 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Stringy))) + i += copy(data[i:], m.Stringy) + return i, nil +} +func (m *CustomOneof_CustomType) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x9a + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(m.CustomType.Size())) + n7, err := m.CustomType.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n7 + return i, nil +} +func (m *CustomOneof_CastType) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0xa0 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(m.CastType)) + return i, nil +} +func (m *CustomOneof_MyCustomName) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0xa8 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(m.MyCustomName)) + return i, nil +} +func encodeFixed64One(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32One(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintOne(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *Subby) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Subby: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Subby: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sub", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Sub = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOneUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOneUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AllTypesOneOf) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AllTypesOneOf: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AllTypesOneOf: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.TestOneof = &AllTypesOneOf_Field1{v} + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.TestOneof = &AllTypesOneOf_Field2{v} + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &AllTypesOneOf_Field3{v} + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &AllTypesOneOf_Field4{v} + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &AllTypesOneOf_Field5{v} + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &AllTypesOneOf_Field6{v} + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.TestOneof = &AllTypesOneOf_Field7{v} + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.TestOneof = &AllTypesOneOf_Field8{int64(v)} + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.TestOneof = &AllTypesOneOf_Field9{v} + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.TestOneof = &AllTypesOneOf_Field10{v} + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.TestOneof = &AllTypesOneOf_Field11{v} + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.TestOneof = &AllTypesOneOf_Field12{v} + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.TestOneof = &AllTypesOneOf_Field13{b} + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TestOneof = &AllTypesOneOf_Field14{string(data[iNdEx:postIndex])} + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := make([]byte, postIndex-iNdEx) + copy(v, data[iNdEx:postIndex]) + m.TestOneof = &AllTypesOneOf_Field15{v} + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &Subby{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.TestOneof = &AllTypesOneOf_SubMessage{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOneUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOneUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TwoOneofs) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TwoOneofs: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TwoOneofs: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.One = &TwoOneofs_Field1{v} + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.One = &TwoOneofs_Field2{v} + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.One = &TwoOneofs_Field3{v} + case 34: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field34", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Two = &TwoOneofs_Field34{string(data[iNdEx:postIndex])} + iNdEx = postIndex + case 35: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field35", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := make([]byte, postIndex-iNdEx) + copy(v, data[iNdEx:postIndex]) + m.Two = &TwoOneofs_Field35{v} + iNdEx = postIndex + case 36: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubMessage2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &Subby{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.Two = &TwoOneofs_SubMessage2{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOneUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOneUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomOneof) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomOneof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomOneof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 34: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Stringy", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Custom = &CustomOneof_Stringy{string(data[iNdEx:postIndex])} + iNdEx = postIndex + case 35: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CustomType", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var vv github_com_gogo_protobuf_test_custom.Uint128 + v := &vv + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.Custom = &CustomOneof_CustomType{*v} + iNdEx = postIndex + case 36: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CastType", wireType) + } + var v github_com_gogo_protobuf_test_casttype.MyUint64Type + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (github_com_gogo_protobuf_test_casttype.MyUint64Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Custom = &CustomOneof_CastType{v} + case 37: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyCustomName", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Custom = &CustomOneof_MyCustomName{v} + default: + iNdEx = preIndex + skippy, err := skipOneUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOneUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipOneUnsafe(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthOneUnsafe + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipOneUnsafe(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthOneUnsafe = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowOneUnsafe = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeboth/one.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeboth/one.proto new file mode 100644 index 0000000000000000000000000000000000000000..9d6230ad65a98832e61077f0f2de16a5351d6483 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeboth/one.proto @@ -0,0 +1,101 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package one; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = true; +option (gogoproto.unsafe_unmarshaler_all) = true; + +message Subby { + optional string sub = 1; +} + +message AllTypesOneOf { + oneof test_oneof { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + int64 Field4 = 4; + uint32 Field5 = 5; + uint64 Field6 = 6; + sint32 Field7 = 7; + sint64 Field8 = 8; + fixed32 Field9 = 9; + sfixed32 Field10 = 10; + fixed64 Field11 = 11; + sfixed64 Field12 = 12; + bool Field13 = 13; + string Field14 = 14; + bytes Field15 = 15; + Subby sub_message = 16; + } +} + +message TwoOneofs { + oneof one { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + } + + oneof two { + string Field34 = 34; + bytes Field35 = 35; + Subby sub_message2 = 36; + } +} + +message CustomOneof { + oneof custom { + string Stringy = 34; + bytes CustomType = 35 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; + uint64 CastType = 36 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + int64 CustomName = 37 [(gogoproto.customname) = "MyCustomName"]; + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeboth/onepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeboth/onepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..a99c0bf82673dd257748ab5321497d69d7cbcd34 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeboth/onepb_test.go @@ -0,0 +1,744 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeboth/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/unsafeboth/one.proto + +It has these top-level messages: + Subby + AllTypesOneOf + TwoOneofs + CustomOneof +*/ +package one + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestSubbyProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSubbyMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAllTypesOneOfMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestTwoOneofsMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomOneofMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllTypesOneOfJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTwoOneofsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomOneofJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSubbyProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOneDescription(t *testing.T) { + OneDescription() +} +func TestSubbyVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllTypesOneOfVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTwoOneofsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomOneofVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSubbyGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllTypesOneOfGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTwoOneofsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomOneofGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSubbySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestAllTypesOneOfSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestTwoOneofsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestCustomOneofSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSubbyStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllTypesOneOfStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTwoOneofsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomOneofStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafemarshaler/one.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafemarshaler/one.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..55c6536383032f964622129da24d1bd5b1e0ba59 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafemarshaler/one.pb.go @@ -0,0 +1,5722 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafemarshaler/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/unsafemarshaler/one.proto + +It has these top-level messages: + Subby + AllTypesOneOf + TwoOneofs + CustomOneof +*/ +package one + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_custom "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom" +import github_com_gogo_protobuf_test_casttype "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import unsafe "unsafe" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Subby struct { + Sub *string `protobuf:"bytes,1,opt,name=sub" json:"sub,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Subby) Reset() { *m = Subby{} } +func (*Subby) ProtoMessage() {} + +type AllTypesOneOf struct { + // Types that are valid to be assigned to TestOneof: + // *AllTypesOneOf_Field1 + // *AllTypesOneOf_Field2 + // *AllTypesOneOf_Field3 + // *AllTypesOneOf_Field4 + // *AllTypesOneOf_Field5 + // *AllTypesOneOf_Field6 + // *AllTypesOneOf_Field7 + // *AllTypesOneOf_Field8 + // *AllTypesOneOf_Field9 + // *AllTypesOneOf_Field10 + // *AllTypesOneOf_Field11 + // *AllTypesOneOf_Field12 + // *AllTypesOneOf_Field13 + // *AllTypesOneOf_Field14 + // *AllTypesOneOf_Field15 + // *AllTypesOneOf_SubMessage + TestOneof isAllTypesOneOf_TestOneof `protobuf_oneof:"test_oneof"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllTypesOneOf) Reset() { *m = AllTypesOneOf{} } +func (*AllTypesOneOf) ProtoMessage() {} + +type isAllTypesOneOf_TestOneof interface { + isAllTypesOneOf_TestOneof() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} + +type AllTypesOneOf_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,oneof"` +} +type AllTypesOneOf_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,oneof"` +} +type AllTypesOneOf_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,oneof"` +} +type AllTypesOneOf_Field4 struct { + Field4 int64 `protobuf:"varint,4,opt,name=Field4,oneof"` +} +type AllTypesOneOf_Field5 struct { + Field5 uint32 `protobuf:"varint,5,opt,name=Field5,oneof"` +} +type AllTypesOneOf_Field6 struct { + Field6 uint64 `protobuf:"varint,6,opt,name=Field6,oneof"` +} +type AllTypesOneOf_Field7 struct { + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7,oneof"` +} +type AllTypesOneOf_Field8 struct { + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8,oneof"` +} +type AllTypesOneOf_Field9 struct { + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9,oneof"` +} +type AllTypesOneOf_Field10 struct { + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10,oneof"` +} +type AllTypesOneOf_Field11 struct { + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11,oneof"` +} +type AllTypesOneOf_Field12 struct { + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12,oneof"` +} +type AllTypesOneOf_Field13 struct { + Field13 bool `protobuf:"varint,13,opt,name=Field13,oneof"` +} +type AllTypesOneOf_Field14 struct { + Field14 string `protobuf:"bytes,14,opt,name=Field14,oneof"` +} +type AllTypesOneOf_Field15 struct { + Field15 []byte `protobuf:"bytes,15,opt,name=Field15,oneof"` +} +type AllTypesOneOf_SubMessage struct { + SubMessage *Subby `protobuf:"bytes,16,opt,name=sub_message,oneof"` +} + +func (*AllTypesOneOf_Field1) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field2) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field3) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field4) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field5) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field6) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field7) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field8) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field9) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field10) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field11) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field12) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field13) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field14) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field15) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_SubMessage) isAllTypesOneOf_TestOneof() {} + +func (m *AllTypesOneOf) GetTestOneof() isAllTypesOneOf_TestOneof { + if m != nil { + return m.TestOneof + } + return nil +} + +func (m *AllTypesOneOf) GetField1() float64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *AllTypesOneOf) GetField2() float32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *AllTypesOneOf) GetField3() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *AllTypesOneOf) GetField4() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field4); ok { + return x.Field4 + } + return 0 +} + +func (m *AllTypesOneOf) GetField5() uint32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field5); ok { + return x.Field5 + } + return 0 +} + +func (m *AllTypesOneOf) GetField6() uint64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field6); ok { + return x.Field6 + } + return 0 +} + +func (m *AllTypesOneOf) GetField7() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field7); ok { + return x.Field7 + } + return 0 +} + +func (m *AllTypesOneOf) GetField8() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field8); ok { + return x.Field8 + } + return 0 +} + +func (m *AllTypesOneOf) GetField9() uint32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field9); ok { + return x.Field9 + } + return 0 +} + +func (m *AllTypesOneOf) GetField10() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field10); ok { + return x.Field10 + } + return 0 +} + +func (m *AllTypesOneOf) GetField11() uint64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field11); ok { + return x.Field11 + } + return 0 +} + +func (m *AllTypesOneOf) GetField12() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field12); ok { + return x.Field12 + } + return 0 +} + +func (m *AllTypesOneOf) GetField13() bool { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field13); ok { + return x.Field13 + } + return false +} + +func (m *AllTypesOneOf) GetField14() string { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field14); ok { + return x.Field14 + } + return "" +} + +func (m *AllTypesOneOf) GetField15() []byte { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field15); ok { + return x.Field15 + } + return nil +} + +func (m *AllTypesOneOf) GetSubMessage() *Subby { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_SubMessage); ok { + return x.SubMessage + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*AllTypesOneOf) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _AllTypesOneOf_OneofMarshaler, _AllTypesOneOf_OneofUnmarshaler, []interface{}{ + (*AllTypesOneOf_Field1)(nil), + (*AllTypesOneOf_Field2)(nil), + (*AllTypesOneOf_Field3)(nil), + (*AllTypesOneOf_Field4)(nil), + (*AllTypesOneOf_Field5)(nil), + (*AllTypesOneOf_Field6)(nil), + (*AllTypesOneOf_Field7)(nil), + (*AllTypesOneOf_Field8)(nil), + (*AllTypesOneOf_Field9)(nil), + (*AllTypesOneOf_Field10)(nil), + (*AllTypesOneOf_Field11)(nil), + (*AllTypesOneOf_Field12)(nil), + (*AllTypesOneOf_Field13)(nil), + (*AllTypesOneOf_Field14)(nil), + (*AllTypesOneOf_Field15)(nil), + (*AllTypesOneOf_SubMessage)(nil), + } +} + +func _AllTypesOneOf_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*AllTypesOneOf) + // test_oneof + switch x := m.TestOneof.(type) { + case *AllTypesOneOf_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *AllTypesOneOf_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *AllTypesOneOf_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case *AllTypesOneOf_Field4: + _ = b.EncodeVarint(4<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field4)) + case *AllTypesOneOf_Field5: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field5)) + case *AllTypesOneOf_Field6: + _ = b.EncodeVarint(6<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field6)) + case *AllTypesOneOf_Field7: + _ = b.EncodeVarint(7<<3 | proto.WireVarint) + _ = b.EncodeZigzag32(uint64(x.Field7)) + case *AllTypesOneOf_Field8: + _ = b.EncodeVarint(8<<3 | proto.WireVarint) + _ = b.EncodeZigzag64(uint64(x.Field8)) + case *AllTypesOneOf_Field9: + _ = b.EncodeVarint(9<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field9)) + case *AllTypesOneOf_Field10: + _ = b.EncodeVarint(10<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field10)) + case *AllTypesOneOf_Field11: + _ = b.EncodeVarint(11<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field11)) + case *AllTypesOneOf_Field12: + _ = b.EncodeVarint(12<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field12)) + case *AllTypesOneOf_Field13: + t := uint64(0) + if x.Field13 { + t = 1 + } + _ = b.EncodeVarint(13<<3 | proto.WireVarint) + _ = b.EncodeVarint(t) + case *AllTypesOneOf_Field14: + _ = b.EncodeVarint(14<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field14) + case *AllTypesOneOf_Field15: + _ = b.EncodeVarint(15<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field15) + case *AllTypesOneOf_SubMessage: + _ = b.EncodeVarint(16<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("AllTypesOneOf.TestOneof has unexpected type %T", x) + } + return nil +} + +func _AllTypesOneOf_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*AllTypesOneOf) + switch tag { + case 1: // test_oneof.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field1{math.Float64frombits(x)} + return true, err + case 2: // test_oneof.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // test_oneof.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field3{int32(x)} + return true, err + case 4: // test_oneof.Field4 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field4{int64(x)} + return true, err + case 5: // test_oneof.Field5 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field5{uint32(x)} + return true, err + case 6: // test_oneof.Field6 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field6{x} + return true, err + case 7: // test_oneof.Field7 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag32() + m.TestOneof = &AllTypesOneOf_Field7{int32(x)} + return true, err + case 8: // test_oneof.Field8 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag64() + m.TestOneof = &AllTypesOneOf_Field8{int64(x)} + return true, err + case 9: // test_oneof.Field9 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field9{uint32(x)} + return true, err + case 10: // test_oneof.Field10 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field10{int32(x)} + return true, err + case 11: // test_oneof.Field11 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field11{x} + return true, err + case 12: // test_oneof.Field12 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field12{int64(x)} + return true, err + case 13: // test_oneof.Field13 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field13{x != 0} + return true, err + case 14: // test_oneof.Field14 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.TestOneof = &AllTypesOneOf_Field14{x} + return true, err + case 15: // test_oneof.Field15 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.TestOneof = &AllTypesOneOf_Field15{x} + return true, err + case 16: // test_oneof.sub_message + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.TestOneof = &AllTypesOneOf_SubMessage{msg} + return true, err + default: + return false, nil + } +} + +type TwoOneofs struct { + // Types that are valid to be assigned to One: + // *TwoOneofs_Field1 + // *TwoOneofs_Field2 + // *TwoOneofs_Field3 + One isTwoOneofs_One `protobuf_oneof:"one"` + // Types that are valid to be assigned to Two: + // *TwoOneofs_Field34 + // *TwoOneofs_Field35 + // *TwoOneofs_SubMessage2 + Two isTwoOneofs_Two `protobuf_oneof:"two"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TwoOneofs) Reset() { *m = TwoOneofs{} } +func (*TwoOneofs) ProtoMessage() {} + +type isTwoOneofs_One interface { + isTwoOneofs_One() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} +type isTwoOneofs_Two interface { + isTwoOneofs_Two() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} + +type TwoOneofs_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,oneof"` +} +type TwoOneofs_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,oneof"` +} +type TwoOneofs_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,oneof"` +} +type TwoOneofs_Field34 struct { + Field34 string `protobuf:"bytes,34,opt,name=Field34,oneof"` +} +type TwoOneofs_Field35 struct { + Field35 []byte `protobuf:"bytes,35,opt,name=Field35,oneof"` +} +type TwoOneofs_SubMessage2 struct { + SubMessage2 *Subby `protobuf:"bytes,36,opt,name=sub_message2,oneof"` +} + +func (*TwoOneofs_Field1) isTwoOneofs_One() {} +func (*TwoOneofs_Field2) isTwoOneofs_One() {} +func (*TwoOneofs_Field3) isTwoOneofs_One() {} +func (*TwoOneofs_Field34) isTwoOneofs_Two() {} +func (*TwoOneofs_Field35) isTwoOneofs_Two() {} +func (*TwoOneofs_SubMessage2) isTwoOneofs_Two() {} + +func (m *TwoOneofs) GetOne() isTwoOneofs_One { + if m != nil { + return m.One + } + return nil +} +func (m *TwoOneofs) GetTwo() isTwoOneofs_Two { + if m != nil { + return m.Two + } + return nil +} + +func (m *TwoOneofs) GetField1() float64 { + if x, ok := m.GetOne().(*TwoOneofs_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *TwoOneofs) GetField2() float32 { + if x, ok := m.GetOne().(*TwoOneofs_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *TwoOneofs) GetField3() int32 { + if x, ok := m.GetOne().(*TwoOneofs_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *TwoOneofs) GetField34() string { + if x, ok := m.GetTwo().(*TwoOneofs_Field34); ok { + return x.Field34 + } + return "" +} + +func (m *TwoOneofs) GetField35() []byte { + if x, ok := m.GetTwo().(*TwoOneofs_Field35); ok { + return x.Field35 + } + return nil +} + +func (m *TwoOneofs) GetSubMessage2() *Subby { + if x, ok := m.GetTwo().(*TwoOneofs_SubMessage2); ok { + return x.SubMessage2 + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*TwoOneofs) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _TwoOneofs_OneofMarshaler, _TwoOneofs_OneofUnmarshaler, []interface{}{ + (*TwoOneofs_Field1)(nil), + (*TwoOneofs_Field2)(nil), + (*TwoOneofs_Field3)(nil), + (*TwoOneofs_Field34)(nil), + (*TwoOneofs_Field35)(nil), + (*TwoOneofs_SubMessage2)(nil), + } +} + +func _TwoOneofs_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*TwoOneofs) + // one + switch x := m.One.(type) { + case *TwoOneofs_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *TwoOneofs_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *TwoOneofs_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case nil: + default: + return fmt.Errorf("TwoOneofs.One has unexpected type %T", x) + } + // two + switch x := m.Two.(type) { + case *TwoOneofs_Field34: + _ = b.EncodeVarint(34<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field34) + case *TwoOneofs_Field35: + _ = b.EncodeVarint(35<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field35) + case *TwoOneofs_SubMessage2: + _ = b.EncodeVarint(36<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage2); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("TwoOneofs.Two has unexpected type %T", x) + } + return nil +} + +func _TwoOneofs_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*TwoOneofs) + switch tag { + case 1: // one.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.One = &TwoOneofs_Field1{math.Float64frombits(x)} + return true, err + case 2: // one.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.One = &TwoOneofs_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // one.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.One = &TwoOneofs_Field3{int32(x)} + return true, err + case 34: // two.Field34 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Two = &TwoOneofs_Field34{x} + return true, err + case 35: // two.Field35 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.Two = &TwoOneofs_Field35{x} + return true, err + case 36: // two.sub_message2 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.Two = &TwoOneofs_SubMessage2{msg} + return true, err + default: + return false, nil + } +} + +type CustomOneof struct { + // Types that are valid to be assigned to Custom: + // *CustomOneof_Stringy + // *CustomOneof_CustomType + // *CustomOneof_CastType + // *CustomOneof_MyCustomName + Custom isCustomOneof_Custom `protobuf_oneof:"custom"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomOneof) Reset() { *m = CustomOneof{} } +func (*CustomOneof) ProtoMessage() {} + +type isCustomOneof_Custom interface { + isCustomOneof_Custom() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} + +type CustomOneof_Stringy struct { + Stringy string `protobuf:"bytes,34,opt,name=Stringy,oneof"` +} +type CustomOneof_CustomType struct { + CustomType github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,35,opt,name=CustomType,oneof,customtype=github.com/gogo/protobuf/test/custom.Uint128"` +} +type CustomOneof_CastType struct { + CastType github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,36,opt,name=CastType,oneof,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type"` +} +type CustomOneof_MyCustomName struct { + MyCustomName int64 `protobuf:"varint,37,opt,name=CustomName,oneof"` +} + +func (*CustomOneof_Stringy) isCustomOneof_Custom() {} +func (*CustomOneof_CustomType) isCustomOneof_Custom() {} +func (*CustomOneof_CastType) isCustomOneof_Custom() {} +func (*CustomOneof_MyCustomName) isCustomOneof_Custom() {} + +func (m *CustomOneof) GetCustom() isCustomOneof_Custom { + if m != nil { + return m.Custom + } + return nil +} + +func (m *CustomOneof) GetStringy() string { + if x, ok := m.GetCustom().(*CustomOneof_Stringy); ok { + return x.Stringy + } + return "" +} + +func (m *CustomOneof) GetCastType() github_com_gogo_protobuf_test_casttype.MyUint64Type { + if x, ok := m.GetCustom().(*CustomOneof_CastType); ok { + return x.CastType + } + return 0 +} + +func (m *CustomOneof) GetMyCustomName() int64 { + if x, ok := m.GetCustom().(*CustomOneof_MyCustomName); ok { + return x.MyCustomName + } + return 0 +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*CustomOneof) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _CustomOneof_OneofMarshaler, _CustomOneof_OneofUnmarshaler, []interface{}{ + (*CustomOneof_Stringy)(nil), + (*CustomOneof_CustomType)(nil), + (*CustomOneof_CastType)(nil), + (*CustomOneof_MyCustomName)(nil), + } +} + +func _CustomOneof_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*CustomOneof) + // custom + switch x := m.Custom.(type) { + case *CustomOneof_Stringy: + _ = b.EncodeVarint(34<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Stringy) + case *CustomOneof_CustomType: + _ = b.EncodeVarint(35<<3 | proto.WireBytes) + data, err := x.CustomType.Marshal() + if err != nil { + return err + } + _ = b.EncodeRawBytes(data) + case *CustomOneof_CastType: + _ = b.EncodeVarint(36<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.CastType)) + case *CustomOneof_MyCustomName: + _ = b.EncodeVarint(37<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.MyCustomName)) + case nil: + default: + return fmt.Errorf("CustomOneof.Custom has unexpected type %T", x) + } + return nil +} + +func _CustomOneof_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*CustomOneof) + switch tag { + case 34: // custom.Stringy + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Custom = &CustomOneof_Stringy{x} + return true, err + case 35: // custom.CustomType + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + if err != nil { + return true, err + } + var cc github_com_gogo_protobuf_test_custom.Uint128 + c := &cc + err = c.Unmarshal(x) + m.Custom = &CustomOneof_CustomType{*c} + return true, err + case 36: // custom.CastType + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Custom = &CustomOneof_CastType{github_com_gogo_protobuf_test_casttype.MyUint64Type(x)} + return true, err + case 37: // custom.CustomName + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Custom = &CustomOneof_MyCustomName{int64(x)} + return true, err + default: + return false, nil + } +} + +func (this *Subby) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *AllTypesOneOf) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *TwoOneofs) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *CustomOneof) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func OneDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unsafemarshaler/one.proto"), + Package: func(v string) *string { return &v }("one"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Subby"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("sub"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("AllTypesOneOf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("sub_message"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(0), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("test_oneof")}}, + }, {Name: func(v string) *string { return &v }("TwoOneofs"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field34"), + Number: func(v int32) *int32 { return &v }(34), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("Field35"), + Number: func(v int32) *int32 { return &v }(35), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("sub_message2"), + Number: func(v int32) *int32 { return &v }(36), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(1), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("one")}, {Name: func(v string) *string { return &v }("two")}}, + }, {Name: func(v string) *string { return &v }("CustomOneof"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Stringy"), + Number: func(v int32) *int32 { return &v }(34), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CustomType"), + Number: func(v int32) *int32 { return &v }(35), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }, {Name: func(v string) *string { return &v }("CastType"), + Number: func(v int32) *int32 { return &v }(36), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("CustomName"), + Number: func(v int32) *int32 { return &v }(37), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0xc, 0x4d, 0x79, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4e, 0x61, 0x6d, 0x65})}}, + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("custom")}}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x1}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (this *Subby) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Subby) + if !ok { + return fmt.Errorf("that is not of type *Subby") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Subby but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Subbybut is not nil && this == nil") + } + if this.Sub != nil && that1.Sub != nil { + if *this.Sub != *that1.Sub { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", *this.Sub, *that1.Sub) + } + } else if this.Sub != nil { + return fmt.Errorf("this.Sub == nil && that.Sub != nil") + } else if that1.Sub != nil { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Subby) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Subby) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Sub != nil && that1.Sub != nil { + if *this.Sub != *that1.Sub { + return false + } + } else if this.Sub != nil { + return false + } else if that1.Sub != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllTypesOneOf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOfbut is not nil && this == nil") + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return fmt.Errorf("this.TestOneof != nil && that1.TestOneof == nil") + } + } else if this.TestOneof == nil { + return fmt.Errorf("this.TestOneof == nil && that1.TestOneof != nil") + } else if err := this.TestOneof.VerboseEqual(that1.TestOneof); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AllTypesOneOf_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field1) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *AllTypesOneOf_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field2) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *AllTypesOneOf_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field3) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *AllTypesOneOf_Field4) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field4) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field4") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field4 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field4but is not nil && this == nil") + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + return nil +} +func (this *AllTypesOneOf_Field5) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field5) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field5") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field5 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field5but is not nil && this == nil") + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + return nil +} +func (this *AllTypesOneOf_Field6) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field6) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field6") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field6 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field6but is not nil && this == nil") + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + return nil +} +func (this *AllTypesOneOf_Field7) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field7) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field7") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field7 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field7but is not nil && this == nil") + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + return nil +} +func (this *AllTypesOneOf_Field8) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field8) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field8") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field8 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field8but is not nil && this == nil") + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + return nil +} +func (this *AllTypesOneOf_Field9) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field9) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field9") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field9 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field9but is not nil && this == nil") + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + return nil +} +func (this *AllTypesOneOf_Field10) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field10) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field10") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field10 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field10but is not nil && this == nil") + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + return nil +} +func (this *AllTypesOneOf_Field11) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field11) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field11") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field11 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field11but is not nil && this == nil") + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + return nil +} +func (this *AllTypesOneOf_Field12) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field12) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field12") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field12 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field12but is not nil && this == nil") + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + return nil +} +func (this *AllTypesOneOf_Field13) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field13) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field13") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field13 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field13but is not nil && this == nil") + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + return nil +} +func (this *AllTypesOneOf_Field14) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field14) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field14") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field14 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field14but is not nil && this == nil") + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + return nil +} +func (this *AllTypesOneOf_Field15) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field15) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field15") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field15 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field15but is not nil && this == nil") + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + return nil +} +func (this *AllTypesOneOf_SubMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_SubMessage) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_SubMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_SubMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_SubMessagebut is not nil && this == nil") + } + if !this.SubMessage.Equal(that1.SubMessage) { + return fmt.Errorf("SubMessage this(%v) Not Equal that(%v)", this.SubMessage, that1.SubMessage) + } + return nil +} +func (this *AllTypesOneOf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return false + } + } else if this.TestOneof == nil { + return false + } else if !this.TestOneof.Equal(that1.TestOneof) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllTypesOneOf_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *AllTypesOneOf_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *AllTypesOneOf_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *AllTypesOneOf_Field4) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field4) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field4 != that1.Field4 { + return false + } + return true +} +func (this *AllTypesOneOf_Field5) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field5) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field5 != that1.Field5 { + return false + } + return true +} +func (this *AllTypesOneOf_Field6) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field6) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field6 != that1.Field6 { + return false + } + return true +} +func (this *AllTypesOneOf_Field7) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field7) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field7 != that1.Field7 { + return false + } + return true +} +func (this *AllTypesOneOf_Field8) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field8) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field8 != that1.Field8 { + return false + } + return true +} +func (this *AllTypesOneOf_Field9) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field9) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field9 != that1.Field9 { + return false + } + return true +} +func (this *AllTypesOneOf_Field10) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field10) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field10 != that1.Field10 { + return false + } + return true +} +func (this *AllTypesOneOf_Field11) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field11) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field11 != that1.Field11 { + return false + } + return true +} +func (this *AllTypesOneOf_Field12) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field12) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field12 != that1.Field12 { + return false + } + return true +} +func (this *AllTypesOneOf_Field13) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field13) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field13 != that1.Field13 { + return false + } + return true +} +func (this *AllTypesOneOf_Field14) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field14) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field14 != that1.Field14 { + return false + } + return true +} +func (this *AllTypesOneOf_Field15) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field15) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + return true +} +func (this *AllTypesOneOf_SubMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_SubMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage.Equal(that1.SubMessage) { + return false + } + return true +} +func (this *TwoOneofs) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofsbut is not nil && this == nil") + } + if that1.One == nil { + if this.One != nil { + return fmt.Errorf("this.One != nil && that1.One == nil") + } + } else if this.One == nil { + return fmt.Errorf("this.One == nil && that1.One != nil") + } else if err := this.One.VerboseEqual(that1.One); err != nil { + return err + } + if that1.Two == nil { + if this.Two != nil { + return fmt.Errorf("this.Two != nil && that1.Two == nil") + } + } else if this.Two == nil { + return fmt.Errorf("this.Two == nil && that1.Two != nil") + } else if err := this.Two.VerboseEqual(that1.Two); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *TwoOneofs_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field1) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *TwoOneofs_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field2) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *TwoOneofs_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field3) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *TwoOneofs_Field34) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field34) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field34") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field34 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field34but is not nil && this == nil") + } + if this.Field34 != that1.Field34 { + return fmt.Errorf("Field34 this(%v) Not Equal that(%v)", this.Field34, that1.Field34) + } + return nil +} +func (this *TwoOneofs_Field35) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field35) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field35") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field35 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field35but is not nil && this == nil") + } + if !bytes.Equal(this.Field35, that1.Field35) { + return fmt.Errorf("Field35 this(%v) Not Equal that(%v)", this.Field35, that1.Field35) + } + return nil +} +func (this *TwoOneofs_SubMessage2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_SubMessage2) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_SubMessage2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_SubMessage2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_SubMessage2but is not nil && this == nil") + } + if !this.SubMessage2.Equal(that1.SubMessage2) { + return fmt.Errorf("SubMessage2 this(%v) Not Equal that(%v)", this.SubMessage2, that1.SubMessage2) + } + return nil +} +func (this *TwoOneofs) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.One == nil { + if this.One != nil { + return false + } + } else if this.One == nil { + return false + } else if !this.One.Equal(that1.One) { + return false + } + if that1.Two == nil { + if this.Two != nil { + return false + } + } else if this.Two == nil { + return false + } else if !this.Two.Equal(that1.Two) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *TwoOneofs_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *TwoOneofs_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *TwoOneofs_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *TwoOneofs_Field34) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field34) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field34 != that1.Field34 { + return false + } + return true +} +func (this *TwoOneofs_Field35) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field35) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field35, that1.Field35) { + return false + } + return true +} +func (this *TwoOneofs_SubMessage2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_SubMessage2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage2.Equal(that1.SubMessage2) { + return false + } + return true +} +func (this *CustomOneof) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneofbut is not nil && this == nil") + } + if that1.Custom == nil { + if this.Custom != nil { + return fmt.Errorf("this.Custom != nil && that1.Custom == nil") + } + } else if this.Custom == nil { + return fmt.Errorf("this.Custom == nil && that1.Custom != nil") + } else if err := this.Custom.VerboseEqual(that1.Custom); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomOneof_Stringy) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_Stringy) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_Stringy") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_Stringy but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_Stringybut is not nil && this == nil") + } + if this.Stringy != that1.Stringy { + return fmt.Errorf("Stringy this(%v) Not Equal that(%v)", this.Stringy, that1.Stringy) + } + return nil +} +func (this *CustomOneof_CustomType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_CustomType) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_CustomType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_CustomType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_CustomTypebut is not nil && this == nil") + } + if !this.CustomType.Equal(that1.CustomType) { + return fmt.Errorf("CustomType this(%v) Not Equal that(%v)", this.CustomType, that1.CustomType) + } + return nil +} +func (this *CustomOneof_CastType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_CastType) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_CastType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_CastType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_CastTypebut is not nil && this == nil") + } + if this.CastType != that1.CastType { + return fmt.Errorf("CastType this(%v) Not Equal that(%v)", this.CastType, that1.CastType) + } + return nil +} +func (this *CustomOneof_MyCustomName) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_MyCustomName) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_MyCustomName") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_MyCustomName but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_MyCustomNamebut is not nil && this == nil") + } + if this.MyCustomName != that1.MyCustomName { + return fmt.Errorf("MyCustomName this(%v) Not Equal that(%v)", this.MyCustomName, that1.MyCustomName) + } + return nil +} +func (this *CustomOneof) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Custom == nil { + if this.Custom != nil { + return false + } + } else if this.Custom == nil { + return false + } else if !this.Custom.Equal(that1.Custom) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomOneof_Stringy) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_Stringy) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Stringy != that1.Stringy { + return false + } + return true +} +func (this *CustomOneof_CustomType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_CustomType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.CustomType.Equal(that1.CustomType) { + return false + } + return true +} +func (this *CustomOneof_CastType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_CastType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.CastType != that1.CastType { + return false + } + return true +} +func (this *CustomOneof_MyCustomName) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_MyCustomName) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.MyCustomName != that1.MyCustomName { + return false + } + return true +} +func (this *Subby) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&one.Subby{") + if this.Sub != nil { + s = append(s, "Sub: "+valueToGoStringOne(this.Sub, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllTypesOneOf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 20) + s = append(s, "&one.AllTypesOneOf{") + if this.TestOneof != nil { + s = append(s, "TestOneof: "+fmt.Sprintf("%#v", this.TestOneof)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllTypesOneOf_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field4) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field4{` + + `Field4:` + fmt.Sprintf("%#v", this.Field4) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field5) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field5{` + + `Field5:` + fmt.Sprintf("%#v", this.Field5) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field6) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field6{` + + `Field6:` + fmt.Sprintf("%#v", this.Field6) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field7) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field7{` + + `Field7:` + fmt.Sprintf("%#v", this.Field7) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field8) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field8{` + + `Field8:` + fmt.Sprintf("%#v", this.Field8) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field9) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field9{` + + `Field9:` + fmt.Sprintf("%#v", this.Field9) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field10) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field10{` + + `Field10:` + fmt.Sprintf("%#v", this.Field10) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field11) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field11{` + + `Field11:` + fmt.Sprintf("%#v", this.Field11) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field12) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field12{` + + `Field12:` + fmt.Sprintf("%#v", this.Field12) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field13) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field13{` + + `Field13:` + fmt.Sprintf("%#v", this.Field13) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field14) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field14{` + + `Field14:` + fmt.Sprintf("%#v", this.Field14) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field15) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field15{` + + `Field15:` + fmt.Sprintf("%#v", this.Field15) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_SubMessage) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_SubMessage{` + + `SubMessage:` + fmt.Sprintf("%#v", this.SubMessage) + `}`}, ", ") + return s +} +func (this *TwoOneofs) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 10) + s = append(s, "&one.TwoOneofs{") + if this.One != nil { + s = append(s, "One: "+fmt.Sprintf("%#v", this.One)+",\n") + } + if this.Two != nil { + s = append(s, "Two: "+fmt.Sprintf("%#v", this.Two)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *TwoOneofs_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field34) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field34{` + + `Field34:` + fmt.Sprintf("%#v", this.Field34) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field35) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field35{` + + `Field35:` + fmt.Sprintf("%#v", this.Field35) + `}`}, ", ") + return s +} +func (this *TwoOneofs_SubMessage2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_SubMessage2{` + + `SubMessage2:` + fmt.Sprintf("%#v", this.SubMessage2) + `}`}, ", ") + return s +} +func (this *CustomOneof) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&one.CustomOneof{") + if this.Custom != nil { + s = append(s, "Custom: "+fmt.Sprintf("%#v", this.Custom)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomOneof_Stringy) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_Stringy{` + + `Stringy:` + fmt.Sprintf("%#v", this.Stringy) + `}`}, ", ") + return s +} +func (this *CustomOneof_CustomType) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_CustomType{` + + `CustomType:` + fmt.Sprintf("%#v", this.CustomType) + `}`}, ", ") + return s +} +func (this *CustomOneof_CastType) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_CastType{` + + `CastType:` + fmt.Sprintf("%#v", this.CastType) + `}`}, ", ") + return s +} +func (this *CustomOneof_MyCustomName) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_MyCustomName{` + + `MyCustomName:` + fmt.Sprintf("%#v", this.MyCustomName) + `}`}, ", ") + return s +} +func valueToGoStringOne(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringOne(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedSubby(r randyOne, easy bool) *Subby { + this := &Subby{} + if r.Intn(10) != 0 { + v1 := randStringOne(r) + this.Sub = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 2) + } + return this +} + +func NewPopulatedAllTypesOneOf(r randyOne, easy bool) *AllTypesOneOf { + this := &AllTypesOneOf{} + oneofNumber_TestOneof := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}[r.Intn(16)] + switch oneofNumber_TestOneof { + case 1: + this.TestOneof = NewPopulatedAllTypesOneOf_Field1(r, easy) + case 2: + this.TestOneof = NewPopulatedAllTypesOneOf_Field2(r, easy) + case 3: + this.TestOneof = NewPopulatedAllTypesOneOf_Field3(r, easy) + case 4: + this.TestOneof = NewPopulatedAllTypesOneOf_Field4(r, easy) + case 5: + this.TestOneof = NewPopulatedAllTypesOneOf_Field5(r, easy) + case 6: + this.TestOneof = NewPopulatedAllTypesOneOf_Field6(r, easy) + case 7: + this.TestOneof = NewPopulatedAllTypesOneOf_Field7(r, easy) + case 8: + this.TestOneof = NewPopulatedAllTypesOneOf_Field8(r, easy) + case 9: + this.TestOneof = NewPopulatedAllTypesOneOf_Field9(r, easy) + case 10: + this.TestOneof = NewPopulatedAllTypesOneOf_Field10(r, easy) + case 11: + this.TestOneof = NewPopulatedAllTypesOneOf_Field11(r, easy) + case 12: + this.TestOneof = NewPopulatedAllTypesOneOf_Field12(r, easy) + case 13: + this.TestOneof = NewPopulatedAllTypesOneOf_Field13(r, easy) + case 14: + this.TestOneof = NewPopulatedAllTypesOneOf_Field14(r, easy) + case 15: + this.TestOneof = NewPopulatedAllTypesOneOf_Field15(r, easy) + case 16: + this.TestOneof = NewPopulatedAllTypesOneOf_SubMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 17) + } + return this +} + +func NewPopulatedAllTypesOneOf_Field1(r randyOne, easy bool) *AllTypesOneOf_Field1 { + this := &AllTypesOneOf_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field2(r randyOne, easy bool) *AllTypesOneOf_Field2 { + this := &AllTypesOneOf_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field3(r randyOne, easy bool) *AllTypesOneOf_Field3 { + this := &AllTypesOneOf_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field4(r randyOne, easy bool) *AllTypesOneOf_Field4 { + this := &AllTypesOneOf_Field4{} + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field5(r randyOne, easy bool) *AllTypesOneOf_Field5 { + this := &AllTypesOneOf_Field5{} + this.Field5 = uint32(r.Uint32()) + return this +} +func NewPopulatedAllTypesOneOf_Field6(r randyOne, easy bool) *AllTypesOneOf_Field6 { + this := &AllTypesOneOf_Field6{} + this.Field6 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedAllTypesOneOf_Field7(r randyOne, easy bool) *AllTypesOneOf_Field7 { + this := &AllTypesOneOf_Field7{} + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field8(r randyOne, easy bool) *AllTypesOneOf_Field8 { + this := &AllTypesOneOf_Field8{} + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field9(r randyOne, easy bool) *AllTypesOneOf_Field9 { + this := &AllTypesOneOf_Field9{} + this.Field9 = uint32(r.Uint32()) + return this +} +func NewPopulatedAllTypesOneOf_Field10(r randyOne, easy bool) *AllTypesOneOf_Field10 { + this := &AllTypesOneOf_Field10{} + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field11(r randyOne, easy bool) *AllTypesOneOf_Field11 { + this := &AllTypesOneOf_Field11{} + this.Field11 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedAllTypesOneOf_Field12(r randyOne, easy bool) *AllTypesOneOf_Field12 { + this := &AllTypesOneOf_Field12{} + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field13(r randyOne, easy bool) *AllTypesOneOf_Field13 { + this := &AllTypesOneOf_Field13{} + this.Field13 = bool(bool(r.Intn(2) == 0)) + return this +} +func NewPopulatedAllTypesOneOf_Field14(r randyOne, easy bool) *AllTypesOneOf_Field14 { + this := &AllTypesOneOf_Field14{} + this.Field14 = randStringOne(r) + return this +} +func NewPopulatedAllTypesOneOf_Field15(r randyOne, easy bool) *AllTypesOneOf_Field15 { + this := &AllTypesOneOf_Field15{} + v2 := r.Intn(100) + this.Field15 = make([]byte, v2) + for i := 0; i < v2; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedAllTypesOneOf_SubMessage(r randyOne, easy bool) *AllTypesOneOf_SubMessage { + this := &AllTypesOneOf_SubMessage{} + this.SubMessage = NewPopulatedSubby(r, easy) + return this +} +func NewPopulatedTwoOneofs(r randyOne, easy bool) *TwoOneofs { + this := &TwoOneofs{} + oneofNumber_One := []int32{1, 2, 3}[r.Intn(3)] + switch oneofNumber_One { + case 1: + this.One = NewPopulatedTwoOneofs_Field1(r, easy) + case 2: + this.One = NewPopulatedTwoOneofs_Field2(r, easy) + case 3: + this.One = NewPopulatedTwoOneofs_Field3(r, easy) + } + oneofNumber_Two := []int32{34, 35, 36}[r.Intn(3)] + switch oneofNumber_Two { + case 34: + this.Two = NewPopulatedTwoOneofs_Field34(r, easy) + case 35: + this.Two = NewPopulatedTwoOneofs_Field35(r, easy) + case 36: + this.Two = NewPopulatedTwoOneofs_SubMessage2(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 37) + } + return this +} + +func NewPopulatedTwoOneofs_Field1(r randyOne, easy bool) *TwoOneofs_Field1 { + this := &TwoOneofs_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field2(r randyOne, easy bool) *TwoOneofs_Field2 { + this := &TwoOneofs_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field3(r randyOne, easy bool) *TwoOneofs_Field3 { + this := &TwoOneofs_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field34(r randyOne, easy bool) *TwoOneofs_Field34 { + this := &TwoOneofs_Field34{} + this.Field34 = randStringOne(r) + return this +} +func NewPopulatedTwoOneofs_Field35(r randyOne, easy bool) *TwoOneofs_Field35 { + this := &TwoOneofs_Field35{} + v3 := r.Intn(100) + this.Field35 = make([]byte, v3) + for i := 0; i < v3; i++ { + this.Field35[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedTwoOneofs_SubMessage2(r randyOne, easy bool) *TwoOneofs_SubMessage2 { + this := &TwoOneofs_SubMessage2{} + this.SubMessage2 = NewPopulatedSubby(r, easy) + return this +} +func NewPopulatedCustomOneof(r randyOne, easy bool) *CustomOneof { + this := &CustomOneof{} + oneofNumber_Custom := []int32{34, 35, 36, 37}[r.Intn(4)] + switch oneofNumber_Custom { + case 34: + this.Custom = NewPopulatedCustomOneof_Stringy(r, easy) + case 35: + this.Custom = NewPopulatedCustomOneof_CustomType(r, easy) + case 36: + this.Custom = NewPopulatedCustomOneof_CastType(r, easy) + case 37: + this.Custom = NewPopulatedCustomOneof_MyCustomName(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 38) + } + return this +} + +func NewPopulatedCustomOneof_Stringy(r randyOne, easy bool) *CustomOneof_Stringy { + this := &CustomOneof_Stringy{} + this.Stringy = randStringOne(r) + return this +} +func NewPopulatedCustomOneof_CustomType(r randyOne, easy bool) *CustomOneof_CustomType { + this := &CustomOneof_CustomType{} + v4 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.CustomType = *v4 + return this +} +func NewPopulatedCustomOneof_CastType(r randyOne, easy bool) *CustomOneof_CastType { + this := &CustomOneof_CastType{} + this.CastType = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + return this +} +func NewPopulatedCustomOneof_MyCustomName(r randyOne, easy bool) *CustomOneof_MyCustomName { + this := &CustomOneof_MyCustomName{} + this.MyCustomName = int64(r.Int63()) + if r.Intn(2) == 0 { + this.MyCustomName *= -1 + } + return this +} + +type randyOne interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneOne(r randyOne) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringOne(r randyOne) string { + v5 := r.Intn(100) + tmps := make([]rune, v5) + for i := 0; i < v5; i++ { + tmps[i] = randUTF8RuneOne(r) + } + return string(tmps) +} +func randUnrecognizedOne(r randyOne, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldOne(data, r, fieldNumber, wire) + } + return data +} +func randFieldOne(data []byte, r randyOne, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateOne(data, uint64(key)) + v6 := r.Int63() + if r.Intn(2) == 0 { + v6 *= -1 + } + data = encodeVarintPopulateOne(data, uint64(v6)) + case 1: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateOne(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateOne(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateOne(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Subby) Size() (n int) { + var l int + _ = l + if m.Sub != nil { + l = len(*m.Sub) + n += 1 + l + sovOne(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllTypesOneOf) Size() (n int) { + var l int + _ = l + if m.TestOneof != nil { + n += m.TestOneof.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllTypesOneOf_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *AllTypesOneOf_Field4) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field4)) + return n +} +func (m *AllTypesOneOf_Field5) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field5)) + return n +} +func (m *AllTypesOneOf_Field6) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field6)) + return n +} +func (m *AllTypesOneOf_Field7) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field7)) + return n +} +func (m *AllTypesOneOf_Field8) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field8)) + return n +} +func (m *AllTypesOneOf_Field9) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field10) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field11) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field12) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field13) Size() (n int) { + var l int + _ = l + n += 2 + return n +} +func (m *AllTypesOneOf_Field14) Size() (n int) { + var l int + _ = l + l = len(m.Field14) + n += 1 + l + sovOne(uint64(l)) + return n +} +func (m *AllTypesOneOf_Field15) Size() (n int) { + var l int + _ = l + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovOne(uint64(l)) + } + return n +} +func (m *AllTypesOneOf_SubMessage) Size() (n int) { + var l int + _ = l + if m.SubMessage != nil { + l = m.SubMessage.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *TwoOneofs) Size() (n int) { + var l int + _ = l + if m.One != nil { + n += m.One.Size() + } + if m.Two != nil { + n += m.Two.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TwoOneofs_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *TwoOneofs_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *TwoOneofs_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *TwoOneofs_Field34) Size() (n int) { + var l int + _ = l + l = len(m.Field34) + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *TwoOneofs_Field35) Size() (n int) { + var l int + _ = l + if m.Field35 != nil { + l = len(m.Field35) + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *TwoOneofs_SubMessage2) Size() (n int) { + var l int + _ = l + if m.SubMessage2 != nil { + l = m.SubMessage2.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *CustomOneof) Size() (n int) { + var l int + _ = l + if m.Custom != nil { + n += m.Custom.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomOneof_Stringy) Size() (n int) { + var l int + _ = l + l = len(m.Stringy) + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *CustomOneof_CustomType) Size() (n int) { + var l int + _ = l + l = m.CustomType.Size() + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *CustomOneof_CastType) Size() (n int) { + var l int + _ = l + n += 2 + sovOne(uint64(m.CastType)) + return n +} +func (m *CustomOneof_MyCustomName) Size() (n int) { + var l int + _ = l + n += 2 + sovOne(uint64(m.MyCustomName)) + return n +} + +func sovOne(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozOne(x uint64) (n int) { + return sovOne(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Subby) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Subby{`, + `Sub:` + valueToStringOne(this.Sub) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf{`, + `TestOneof:` + fmt.Sprintf("%v", this.TestOneof) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field4) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field4{`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field5) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field5{`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field6) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field6{`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field7) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field7{`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field8) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field8{`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field9) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field9{`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field10) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field10{`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field11) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field11{`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field12) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field12{`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field13) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field13{`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field14) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field14{`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field15) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field15{`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_SubMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_SubMessage{`, + `SubMessage:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs{`, + `One:` + fmt.Sprintf("%v", this.One) + `,`, + `Two:` + fmt.Sprintf("%v", this.Two) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field34) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field34{`, + `Field34:` + fmt.Sprintf("%v", this.Field34) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field35) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field35{`, + `Field35:` + fmt.Sprintf("%v", this.Field35) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_SubMessage2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_SubMessage2{`, + `SubMessage2:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage2), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof{`, + `Custom:` + fmt.Sprintf("%v", this.Custom) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_Stringy) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_Stringy{`, + `Stringy:` + fmt.Sprintf("%v", this.Stringy) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_CustomType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_CustomType{`, + `CustomType:` + fmt.Sprintf("%v", this.CustomType) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_CastType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_CastType{`, + `CastType:` + fmt.Sprintf("%v", this.CastType) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_MyCustomName) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_MyCustomName{`, + `MyCustomName:` + fmt.Sprintf("%v", this.MyCustomName) + `,`, + `}`, + }, "") + return s +} +func valueToStringOne(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Subby) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Subby) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Sub != nil { + data[i] = 0xa + i++ + i = encodeVarintOne(data, i, uint64(len(*m.Sub))) + i += copy(data[i:], *m.Sub) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AllTypesOneOf) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AllTypesOneOf) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.TestOneof != nil { + nn1, err := m.TestOneof.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn1 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *AllTypesOneOf_Field1) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = m.Field1 + i += 8 + return i, nil +} +func (m *AllTypesOneOf_Field2) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = m.Field2 + i += 4 + return i, nil +} +func (m *AllTypesOneOf_Field3) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x18 + i++ + i = encodeVarintOne(data, i, uint64(m.Field3)) + return i, nil +} +func (m *AllTypesOneOf_Field4) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x20 + i++ + i = encodeVarintOne(data, i, uint64(m.Field4)) + return i, nil +} +func (m *AllTypesOneOf_Field5) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x28 + i++ + i = encodeVarintOne(data, i, uint64(m.Field5)) + return i, nil +} +func (m *AllTypesOneOf_Field6) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x30 + i++ + i = encodeVarintOne(data, i, uint64(m.Field6)) + return i, nil +} +func (m *AllTypesOneOf_Field7) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x38 + i++ + i = encodeVarintOne(data, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31)))) + return i, nil +} +func (m *AllTypesOneOf_Field8) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x40 + i++ + i = encodeVarintOne(data, i, uint64((uint64(m.Field8)<<1)^uint64((m.Field8>>63)))) + return i, nil +} +func (m *AllTypesOneOf_Field9) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = m.Field9 + i += 4 + return i, nil +} +func (m *AllTypesOneOf_Field10) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = m.Field10 + i += 4 + return i, nil +} +func (m *AllTypesOneOf_Field11) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = m.Field11 + i += 8 + return i, nil +} +func (m *AllTypesOneOf_Field12) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = m.Field12 + i += 8 + return i, nil +} +func (m *AllTypesOneOf_Field13) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x68 + i++ + if m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + return i, nil +} +func (m *AllTypesOneOf_Field14) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x72 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field14))) + i += copy(data[i:], m.Field14) + return i, nil +} +func (m *AllTypesOneOf_Field15) MarshalTo(data []byte) (int, error) { + i := 0 + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + return i, nil +} +func (m *AllTypesOneOf_SubMessage) MarshalTo(data []byte) (int, error) { + i := 0 + if m.SubMessage != nil { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + i = encodeVarintOne(data, i, uint64(m.SubMessage.Size())) + n2, err := m.SubMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + } + return i, nil +} +func (m *TwoOneofs) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *TwoOneofs) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.One != nil { + nn3, err := m.One.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn3 + } + if m.Two != nil { + nn4, err := m.Two.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn4 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *TwoOneofs_Field1) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = m.Field1 + i += 8 + return i, nil +} +func (m *TwoOneofs_Field2) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = m.Field2 + i += 4 + return i, nil +} +func (m *TwoOneofs_Field3) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x18 + i++ + i = encodeVarintOne(data, i, uint64(m.Field3)) + return i, nil +} +func (m *TwoOneofs_Field34) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x92 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field34))) + i += copy(data[i:], m.Field34) + return i, nil +} +func (m *TwoOneofs_Field35) MarshalTo(data []byte) (int, error) { + i := 0 + if m.Field35 != nil { + data[i] = 0x9a + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field35))) + i += copy(data[i:], m.Field35) + } + return i, nil +} +func (m *TwoOneofs_SubMessage2) MarshalTo(data []byte) (int, error) { + i := 0 + if m.SubMessage2 != nil { + data[i] = 0xa2 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(m.SubMessage2.Size())) + n5, err := m.SubMessage2.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n5 + } + return i, nil +} +func (m *CustomOneof) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *CustomOneof) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Custom != nil { + nn6, err := m.Custom.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn6 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *CustomOneof_Stringy) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x92 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Stringy))) + i += copy(data[i:], m.Stringy) + return i, nil +} +func (m *CustomOneof_CustomType) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x9a + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(m.CustomType.Size())) + n7, err := m.CustomType.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n7 + return i, nil +} +func (m *CustomOneof_CastType) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0xa0 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(m.CastType)) + return i, nil +} +func (m *CustomOneof_MyCustomName) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0xa8 + i++ + data[i] = 0x2 + i++ + i = encodeVarintOne(data, i, uint64(m.MyCustomName)) + return i, nil +} +func encodeFixed64One(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32One(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintOne(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafemarshaler/one.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafemarshaler/one.proto new file mode 100644 index 0000000000000000000000000000000000000000..66b1233b13f2e9c8d711871a23736817540fd677 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafemarshaler/one.proto @@ -0,0 +1,101 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package one; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = true; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Subby { + optional string sub = 1; +} + +message AllTypesOneOf { + oneof test_oneof { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + int64 Field4 = 4; + uint32 Field5 = 5; + uint64 Field6 = 6; + sint32 Field7 = 7; + sint64 Field8 = 8; + fixed32 Field9 = 9; + sfixed32 Field10 = 10; + fixed64 Field11 = 11; + sfixed64 Field12 = 12; + bool Field13 = 13; + string Field14 = 14; + bytes Field15 = 15; + Subby sub_message = 16; + } +} + +message TwoOneofs { + oneof one { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + } + + oneof two { + string Field34 = 34; + bytes Field35 = 35; + Subby sub_message2 = 36; + } +} + +message CustomOneof { + oneof custom { + string Stringy = 34; + bytes CustomType = 35 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; + uint64 CastType = 36 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + int64 CustomName = 37 [(gogoproto.customname) = "MyCustomName"]; + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafemarshaler/onepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafemarshaler/onepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..1b655772f78bdbc22063bc61f5a55cc0822b3be4 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafemarshaler/onepb_test.go @@ -0,0 +1,744 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafemarshaler/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/unsafemarshaler/one.proto + +It has these top-level messages: + Subby + AllTypesOneOf + TwoOneofs + CustomOneof +*/ +package one + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestSubbyProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSubbyMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAllTypesOneOfMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestTwoOneofsMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomOneofMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllTypesOneOfJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTwoOneofsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomOneofJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSubbyProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOneDescription(t *testing.T) { + OneDescription() +} +func TestSubbyVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllTypesOneOfVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTwoOneofsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomOneofVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSubbyGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllTypesOneOfGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTwoOneofsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomOneofGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSubbySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestAllTypesOneOfSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestTwoOneofsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestCustomOneofSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSubbyStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllTypesOneOfStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTwoOneofsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomOneofStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeunmarshaler/one.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeunmarshaler/one.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..cd26720e11942ad80b330f5bb23aeb842c36666b --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeunmarshaler/one.pb.go @@ -0,0 +1,6208 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeunmarshaler/one.proto +// DO NOT EDIT! + +/* + Package one is a generated protocol buffer package. + + It is generated from these files: + combos/unsafeunmarshaler/one.proto + + It has these top-level messages: + Subby + AllTypesOneOf + TwoOneofs + CustomOneof +*/ +package one + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_custom "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom" +import github_com_gogo_protobuf_test_casttype "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/casttype" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" +import unsafe "unsafe" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Subby struct { + Sub *string `protobuf:"bytes,1,opt,name=sub" json:"sub,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Subby) Reset() { *m = Subby{} } +func (*Subby) ProtoMessage() {} + +type AllTypesOneOf struct { + // Types that are valid to be assigned to TestOneof: + // *AllTypesOneOf_Field1 + // *AllTypesOneOf_Field2 + // *AllTypesOneOf_Field3 + // *AllTypesOneOf_Field4 + // *AllTypesOneOf_Field5 + // *AllTypesOneOf_Field6 + // *AllTypesOneOf_Field7 + // *AllTypesOneOf_Field8 + // *AllTypesOneOf_Field9 + // *AllTypesOneOf_Field10 + // *AllTypesOneOf_Field11 + // *AllTypesOneOf_Field12 + // *AllTypesOneOf_Field13 + // *AllTypesOneOf_Field14 + // *AllTypesOneOf_Field15 + // *AllTypesOneOf_SubMessage + TestOneof isAllTypesOneOf_TestOneof `protobuf_oneof:"test_oneof"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AllTypesOneOf) Reset() { *m = AllTypesOneOf{} } +func (*AllTypesOneOf) ProtoMessage() {} + +type isAllTypesOneOf_TestOneof interface { + isAllTypesOneOf_TestOneof() + Equal(interface{}) bool + VerboseEqual(interface{}) error + Size() int +} + +type AllTypesOneOf_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,oneof"` +} +type AllTypesOneOf_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,oneof"` +} +type AllTypesOneOf_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,oneof"` +} +type AllTypesOneOf_Field4 struct { + Field4 int64 `protobuf:"varint,4,opt,name=Field4,oneof"` +} +type AllTypesOneOf_Field5 struct { + Field5 uint32 `protobuf:"varint,5,opt,name=Field5,oneof"` +} +type AllTypesOneOf_Field6 struct { + Field6 uint64 `protobuf:"varint,6,opt,name=Field6,oneof"` +} +type AllTypesOneOf_Field7 struct { + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7,oneof"` +} +type AllTypesOneOf_Field8 struct { + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8,oneof"` +} +type AllTypesOneOf_Field9 struct { + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9,oneof"` +} +type AllTypesOneOf_Field10 struct { + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10,oneof"` +} +type AllTypesOneOf_Field11 struct { + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11,oneof"` +} +type AllTypesOneOf_Field12 struct { + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12,oneof"` +} +type AllTypesOneOf_Field13 struct { + Field13 bool `protobuf:"varint,13,opt,name=Field13,oneof"` +} +type AllTypesOneOf_Field14 struct { + Field14 string `protobuf:"bytes,14,opt,name=Field14,oneof"` +} +type AllTypesOneOf_Field15 struct { + Field15 []byte `protobuf:"bytes,15,opt,name=Field15,oneof"` +} +type AllTypesOneOf_SubMessage struct { + SubMessage *Subby `protobuf:"bytes,16,opt,name=sub_message,oneof"` +} + +func (*AllTypesOneOf_Field1) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field2) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field3) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field4) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field5) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field6) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field7) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field8) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field9) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field10) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field11) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field12) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field13) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field14) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_Field15) isAllTypesOneOf_TestOneof() {} +func (*AllTypesOneOf_SubMessage) isAllTypesOneOf_TestOneof() {} + +func (m *AllTypesOneOf) GetTestOneof() isAllTypesOneOf_TestOneof { + if m != nil { + return m.TestOneof + } + return nil +} + +func (m *AllTypesOneOf) GetField1() float64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *AllTypesOneOf) GetField2() float32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *AllTypesOneOf) GetField3() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *AllTypesOneOf) GetField4() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field4); ok { + return x.Field4 + } + return 0 +} + +func (m *AllTypesOneOf) GetField5() uint32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field5); ok { + return x.Field5 + } + return 0 +} + +func (m *AllTypesOneOf) GetField6() uint64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field6); ok { + return x.Field6 + } + return 0 +} + +func (m *AllTypesOneOf) GetField7() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field7); ok { + return x.Field7 + } + return 0 +} + +func (m *AllTypesOneOf) GetField8() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field8); ok { + return x.Field8 + } + return 0 +} + +func (m *AllTypesOneOf) GetField9() uint32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field9); ok { + return x.Field9 + } + return 0 +} + +func (m *AllTypesOneOf) GetField10() int32 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field10); ok { + return x.Field10 + } + return 0 +} + +func (m *AllTypesOneOf) GetField11() uint64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field11); ok { + return x.Field11 + } + return 0 +} + +func (m *AllTypesOneOf) GetField12() int64 { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field12); ok { + return x.Field12 + } + return 0 +} + +func (m *AllTypesOneOf) GetField13() bool { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field13); ok { + return x.Field13 + } + return false +} + +func (m *AllTypesOneOf) GetField14() string { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field14); ok { + return x.Field14 + } + return "" +} + +func (m *AllTypesOneOf) GetField15() []byte { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_Field15); ok { + return x.Field15 + } + return nil +} + +func (m *AllTypesOneOf) GetSubMessage() *Subby { + if x, ok := m.GetTestOneof().(*AllTypesOneOf_SubMessage); ok { + return x.SubMessage + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*AllTypesOneOf) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _AllTypesOneOf_OneofMarshaler, _AllTypesOneOf_OneofUnmarshaler, []interface{}{ + (*AllTypesOneOf_Field1)(nil), + (*AllTypesOneOf_Field2)(nil), + (*AllTypesOneOf_Field3)(nil), + (*AllTypesOneOf_Field4)(nil), + (*AllTypesOneOf_Field5)(nil), + (*AllTypesOneOf_Field6)(nil), + (*AllTypesOneOf_Field7)(nil), + (*AllTypesOneOf_Field8)(nil), + (*AllTypesOneOf_Field9)(nil), + (*AllTypesOneOf_Field10)(nil), + (*AllTypesOneOf_Field11)(nil), + (*AllTypesOneOf_Field12)(nil), + (*AllTypesOneOf_Field13)(nil), + (*AllTypesOneOf_Field14)(nil), + (*AllTypesOneOf_Field15)(nil), + (*AllTypesOneOf_SubMessage)(nil), + } +} + +func _AllTypesOneOf_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*AllTypesOneOf) + // test_oneof + switch x := m.TestOneof.(type) { + case *AllTypesOneOf_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *AllTypesOneOf_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *AllTypesOneOf_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case *AllTypesOneOf_Field4: + _ = b.EncodeVarint(4<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field4)) + case *AllTypesOneOf_Field5: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field5)) + case *AllTypesOneOf_Field6: + _ = b.EncodeVarint(6<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field6)) + case *AllTypesOneOf_Field7: + _ = b.EncodeVarint(7<<3 | proto.WireVarint) + _ = b.EncodeZigzag32(uint64(x.Field7)) + case *AllTypesOneOf_Field8: + _ = b.EncodeVarint(8<<3 | proto.WireVarint) + _ = b.EncodeZigzag64(uint64(x.Field8)) + case *AllTypesOneOf_Field9: + _ = b.EncodeVarint(9<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field9)) + case *AllTypesOneOf_Field10: + _ = b.EncodeVarint(10<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field10)) + case *AllTypesOneOf_Field11: + _ = b.EncodeVarint(11<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field11)) + case *AllTypesOneOf_Field12: + _ = b.EncodeVarint(12<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field12)) + case *AllTypesOneOf_Field13: + t := uint64(0) + if x.Field13 { + t = 1 + } + _ = b.EncodeVarint(13<<3 | proto.WireVarint) + _ = b.EncodeVarint(t) + case *AllTypesOneOf_Field14: + _ = b.EncodeVarint(14<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field14) + case *AllTypesOneOf_Field15: + _ = b.EncodeVarint(15<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field15) + case *AllTypesOneOf_SubMessage: + _ = b.EncodeVarint(16<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("AllTypesOneOf.TestOneof has unexpected type %T", x) + } + return nil +} + +func _AllTypesOneOf_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*AllTypesOneOf) + switch tag { + case 1: // test_oneof.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field1{math.Float64frombits(x)} + return true, err + case 2: // test_oneof.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // test_oneof.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field3{int32(x)} + return true, err + case 4: // test_oneof.Field4 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field4{int64(x)} + return true, err + case 5: // test_oneof.Field5 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field5{uint32(x)} + return true, err + case 6: // test_oneof.Field6 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field6{x} + return true, err + case 7: // test_oneof.Field7 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag32() + m.TestOneof = &AllTypesOneOf_Field7{int32(x)} + return true, err + case 8: // test_oneof.Field8 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag64() + m.TestOneof = &AllTypesOneOf_Field8{int64(x)} + return true, err + case 9: // test_oneof.Field9 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field9{uint32(x)} + return true, err + case 10: // test_oneof.Field10 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &AllTypesOneOf_Field10{int32(x)} + return true, err + case 11: // test_oneof.Field11 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field11{x} + return true, err + case 12: // test_oneof.Field12 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &AllTypesOneOf_Field12{int64(x)} + return true, err + case 13: // test_oneof.Field13 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &AllTypesOneOf_Field13{x != 0} + return true, err + case 14: // test_oneof.Field14 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.TestOneof = &AllTypesOneOf_Field14{x} + return true, err + case 15: // test_oneof.Field15 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.TestOneof = &AllTypesOneOf_Field15{x} + return true, err + case 16: // test_oneof.sub_message + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.TestOneof = &AllTypesOneOf_SubMessage{msg} + return true, err + default: + return false, nil + } +} + +type TwoOneofs struct { + // Types that are valid to be assigned to One: + // *TwoOneofs_Field1 + // *TwoOneofs_Field2 + // *TwoOneofs_Field3 + One isTwoOneofs_One `protobuf_oneof:"one"` + // Types that are valid to be assigned to Two: + // *TwoOneofs_Field34 + // *TwoOneofs_Field35 + // *TwoOneofs_SubMessage2 + Two isTwoOneofs_Two `protobuf_oneof:"two"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TwoOneofs) Reset() { *m = TwoOneofs{} } +func (*TwoOneofs) ProtoMessage() {} + +type isTwoOneofs_One interface { + isTwoOneofs_One() + Equal(interface{}) bool + VerboseEqual(interface{}) error + Size() int +} +type isTwoOneofs_Two interface { + isTwoOneofs_Two() + Equal(interface{}) bool + VerboseEqual(interface{}) error + Size() int +} + +type TwoOneofs_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,oneof"` +} +type TwoOneofs_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,oneof"` +} +type TwoOneofs_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,oneof"` +} +type TwoOneofs_Field34 struct { + Field34 string `protobuf:"bytes,34,opt,name=Field34,oneof"` +} +type TwoOneofs_Field35 struct { + Field35 []byte `protobuf:"bytes,35,opt,name=Field35,oneof"` +} +type TwoOneofs_SubMessage2 struct { + SubMessage2 *Subby `protobuf:"bytes,36,opt,name=sub_message2,oneof"` +} + +func (*TwoOneofs_Field1) isTwoOneofs_One() {} +func (*TwoOneofs_Field2) isTwoOneofs_One() {} +func (*TwoOneofs_Field3) isTwoOneofs_One() {} +func (*TwoOneofs_Field34) isTwoOneofs_Two() {} +func (*TwoOneofs_Field35) isTwoOneofs_Two() {} +func (*TwoOneofs_SubMessage2) isTwoOneofs_Two() {} + +func (m *TwoOneofs) GetOne() isTwoOneofs_One { + if m != nil { + return m.One + } + return nil +} +func (m *TwoOneofs) GetTwo() isTwoOneofs_Two { + if m != nil { + return m.Two + } + return nil +} + +func (m *TwoOneofs) GetField1() float64 { + if x, ok := m.GetOne().(*TwoOneofs_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *TwoOneofs) GetField2() float32 { + if x, ok := m.GetOne().(*TwoOneofs_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *TwoOneofs) GetField3() int32 { + if x, ok := m.GetOne().(*TwoOneofs_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *TwoOneofs) GetField34() string { + if x, ok := m.GetTwo().(*TwoOneofs_Field34); ok { + return x.Field34 + } + return "" +} + +func (m *TwoOneofs) GetField35() []byte { + if x, ok := m.GetTwo().(*TwoOneofs_Field35); ok { + return x.Field35 + } + return nil +} + +func (m *TwoOneofs) GetSubMessage2() *Subby { + if x, ok := m.GetTwo().(*TwoOneofs_SubMessage2); ok { + return x.SubMessage2 + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*TwoOneofs) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _TwoOneofs_OneofMarshaler, _TwoOneofs_OneofUnmarshaler, []interface{}{ + (*TwoOneofs_Field1)(nil), + (*TwoOneofs_Field2)(nil), + (*TwoOneofs_Field3)(nil), + (*TwoOneofs_Field34)(nil), + (*TwoOneofs_Field35)(nil), + (*TwoOneofs_SubMessage2)(nil), + } +} + +func _TwoOneofs_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*TwoOneofs) + // one + switch x := m.One.(type) { + case *TwoOneofs_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *TwoOneofs_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *TwoOneofs_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case nil: + default: + return fmt.Errorf("TwoOneofs.One has unexpected type %T", x) + } + // two + switch x := m.Two.(type) { + case *TwoOneofs_Field34: + _ = b.EncodeVarint(34<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field34) + case *TwoOneofs_Field35: + _ = b.EncodeVarint(35<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field35) + case *TwoOneofs_SubMessage2: + _ = b.EncodeVarint(36<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage2); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("TwoOneofs.Two has unexpected type %T", x) + } + return nil +} + +func _TwoOneofs_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*TwoOneofs) + switch tag { + case 1: // one.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.One = &TwoOneofs_Field1{math.Float64frombits(x)} + return true, err + case 2: // one.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.One = &TwoOneofs_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // one.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.One = &TwoOneofs_Field3{int32(x)} + return true, err + case 34: // two.Field34 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Two = &TwoOneofs_Field34{x} + return true, err + case 35: // two.Field35 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.Two = &TwoOneofs_Field35{x} + return true, err + case 36: // two.sub_message2 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.Two = &TwoOneofs_SubMessage2{msg} + return true, err + default: + return false, nil + } +} + +type CustomOneof struct { + // Types that are valid to be assigned to Custom: + // *CustomOneof_Stringy + // *CustomOneof_CustomType + // *CustomOneof_CastType + // *CustomOneof_MyCustomName + Custom isCustomOneof_Custom `protobuf_oneof:"custom"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomOneof) Reset() { *m = CustomOneof{} } +func (*CustomOneof) ProtoMessage() {} + +type isCustomOneof_Custom interface { + isCustomOneof_Custom() + Equal(interface{}) bool + VerboseEqual(interface{}) error + Size() int +} + +type CustomOneof_Stringy struct { + Stringy string `protobuf:"bytes,34,opt,name=Stringy,oneof"` +} +type CustomOneof_CustomType struct { + CustomType github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,35,opt,name=CustomType,oneof,customtype=github.com/gogo/protobuf/test/custom.Uint128"` +} +type CustomOneof_CastType struct { + CastType github_com_gogo_protobuf_test_casttype.MyUint64Type `protobuf:"varint,36,opt,name=CastType,oneof,casttype=github.com/gogo/protobuf/test/casttype.MyUint64Type"` +} +type CustomOneof_MyCustomName struct { + MyCustomName int64 `protobuf:"varint,37,opt,name=CustomName,oneof"` +} + +func (*CustomOneof_Stringy) isCustomOneof_Custom() {} +func (*CustomOneof_CustomType) isCustomOneof_Custom() {} +func (*CustomOneof_CastType) isCustomOneof_Custom() {} +func (*CustomOneof_MyCustomName) isCustomOneof_Custom() {} + +func (m *CustomOneof) GetCustom() isCustomOneof_Custom { + if m != nil { + return m.Custom + } + return nil +} + +func (m *CustomOneof) GetStringy() string { + if x, ok := m.GetCustom().(*CustomOneof_Stringy); ok { + return x.Stringy + } + return "" +} + +func (m *CustomOneof) GetCastType() github_com_gogo_protobuf_test_casttype.MyUint64Type { + if x, ok := m.GetCustom().(*CustomOneof_CastType); ok { + return x.CastType + } + return 0 +} + +func (m *CustomOneof) GetMyCustomName() int64 { + if x, ok := m.GetCustom().(*CustomOneof_MyCustomName); ok { + return x.MyCustomName + } + return 0 +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*CustomOneof) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _CustomOneof_OneofMarshaler, _CustomOneof_OneofUnmarshaler, []interface{}{ + (*CustomOneof_Stringy)(nil), + (*CustomOneof_CustomType)(nil), + (*CustomOneof_CastType)(nil), + (*CustomOneof_MyCustomName)(nil), + } +} + +func _CustomOneof_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*CustomOneof) + // custom + switch x := m.Custom.(type) { + case *CustomOneof_Stringy: + _ = b.EncodeVarint(34<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Stringy) + case *CustomOneof_CustomType: + _ = b.EncodeVarint(35<<3 | proto.WireBytes) + data, err := x.CustomType.Marshal() + if err != nil { + return err + } + _ = b.EncodeRawBytes(data) + case *CustomOneof_CastType: + _ = b.EncodeVarint(36<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.CastType)) + case *CustomOneof_MyCustomName: + _ = b.EncodeVarint(37<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.MyCustomName)) + case nil: + default: + return fmt.Errorf("CustomOneof.Custom has unexpected type %T", x) + } + return nil +} + +func _CustomOneof_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*CustomOneof) + switch tag { + case 34: // custom.Stringy + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Custom = &CustomOneof_Stringy{x} + return true, err + case 35: // custom.CustomType + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + if err != nil { + return true, err + } + var cc github_com_gogo_protobuf_test_custom.Uint128 + c := &cc + err = c.Unmarshal(x) + m.Custom = &CustomOneof_CustomType{*c} + return true, err + case 36: // custom.CastType + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Custom = &CustomOneof_CastType{github_com_gogo_protobuf_test_casttype.MyUint64Type(x)} + return true, err + case 37: // custom.CustomName + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Custom = &CustomOneof_MyCustomName{int64(x)} + return true, err + default: + return false, nil + } +} + +func (this *Subby) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *AllTypesOneOf) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *TwoOneofs) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *CustomOneof) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func OneDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unsafeunmarshaler/one.proto"), + Package: func(v string) *string { return &v }("one"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Subby"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("sub"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("AllTypesOneOf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("sub_message"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(0), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("test_oneof")}}, + }, {Name: func(v string) *string { return &v }("TwoOneofs"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field34"), + Number: func(v int32) *int32 { return &v }(34), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("Field35"), + Number: func(v int32) *int32 { return &v }(35), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("sub_message2"), + Number: func(v int32) *int32 { return &v }(36), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(1), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("one")}, {Name: func(v string) *string { return &v }("two")}}, + }, {Name: func(v string) *string { return &v }("CustomOneof"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Stringy"), + Number: func(v int32) *int32 { return &v }(34), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CustomType"), + Number: func(v int32) *int32 { return &v }(35), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }, {Name: func(v string) *string { return &v }("CastType"), + Number: func(v int32) *int32 { return &v }(36), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65007: proto.NewExtension([]byte{0xfa, 0xde, 0x1f, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x4d, 0x79, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x54, 0x79, 0x70, 0x65})}}, + }, {Name: func(v string) *string { return &v }("CustomName"), + Number: func(v int32) *int32 { return &v }(37), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0xc, 0x4d, 0x79, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4e, 0x61, 0x6d, 0x65})}}, + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("custom")}}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x1})}}, + }}, + } +} +func (this *Subby) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Subby) + if !ok { + return fmt.Errorf("that is not of type *Subby") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Subby but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Subbybut is not nil && this == nil") + } + if this.Sub != nil && that1.Sub != nil { + if *this.Sub != *that1.Sub { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", *this.Sub, *that1.Sub) + } + } else if this.Sub != nil { + return fmt.Errorf("this.Sub == nil && that.Sub != nil") + } else if that1.Sub != nil { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Subby) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Subby) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Sub != nil && that1.Sub != nil { + if *this.Sub != *that1.Sub { + return false + } + } else if this.Sub != nil { + return false + } else if that1.Sub != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllTypesOneOf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOfbut is not nil && this == nil") + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return fmt.Errorf("this.TestOneof != nil && that1.TestOneof == nil") + } + } else if this.TestOneof == nil { + return fmt.Errorf("this.TestOneof == nil && that1.TestOneof != nil") + } else if err := this.TestOneof.VerboseEqual(that1.TestOneof); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AllTypesOneOf_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field1) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *AllTypesOneOf_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field2) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *AllTypesOneOf_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field3) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *AllTypesOneOf_Field4) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field4) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field4") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field4 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field4but is not nil && this == nil") + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + return nil +} +func (this *AllTypesOneOf_Field5) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field5) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field5") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field5 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field5but is not nil && this == nil") + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + return nil +} +func (this *AllTypesOneOf_Field6) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field6) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field6") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field6 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field6but is not nil && this == nil") + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + return nil +} +func (this *AllTypesOneOf_Field7) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field7) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field7") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field7 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field7but is not nil && this == nil") + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + return nil +} +func (this *AllTypesOneOf_Field8) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field8) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field8") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field8 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field8but is not nil && this == nil") + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + return nil +} +func (this *AllTypesOneOf_Field9) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field9) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field9") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field9 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field9but is not nil && this == nil") + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + return nil +} +func (this *AllTypesOneOf_Field10) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field10) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field10") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field10 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field10but is not nil && this == nil") + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + return nil +} +func (this *AllTypesOneOf_Field11) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field11) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field11") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field11 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field11but is not nil && this == nil") + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + return nil +} +func (this *AllTypesOneOf_Field12) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field12) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field12") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field12 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field12but is not nil && this == nil") + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + return nil +} +func (this *AllTypesOneOf_Field13) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field13) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field13") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field13 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field13but is not nil && this == nil") + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + return nil +} +func (this *AllTypesOneOf_Field14) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field14) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field14") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field14 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field14but is not nil && this == nil") + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + return nil +} +func (this *AllTypesOneOf_Field15) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_Field15) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_Field15") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_Field15 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_Field15but is not nil && this == nil") + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + return nil +} +func (this *AllTypesOneOf_SubMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllTypesOneOf_SubMessage) + if !ok { + return fmt.Errorf("that is not of type *AllTypesOneOf_SubMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllTypesOneOf_SubMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllTypesOneOf_SubMessagebut is not nil && this == nil") + } + if !this.SubMessage.Equal(that1.SubMessage) { + return fmt.Errorf("SubMessage this(%v) Not Equal that(%v)", this.SubMessage, that1.SubMessage) + } + return nil +} +func (this *AllTypesOneOf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return false + } + } else if this.TestOneof == nil { + return false + } else if !this.TestOneof.Equal(that1.TestOneof) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AllTypesOneOf_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *AllTypesOneOf_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *AllTypesOneOf_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *AllTypesOneOf_Field4) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field4) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field4 != that1.Field4 { + return false + } + return true +} +func (this *AllTypesOneOf_Field5) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field5) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field5 != that1.Field5 { + return false + } + return true +} +func (this *AllTypesOneOf_Field6) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field6) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field6 != that1.Field6 { + return false + } + return true +} +func (this *AllTypesOneOf_Field7) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field7) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field7 != that1.Field7 { + return false + } + return true +} +func (this *AllTypesOneOf_Field8) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field8) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field8 != that1.Field8 { + return false + } + return true +} +func (this *AllTypesOneOf_Field9) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field9) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field9 != that1.Field9 { + return false + } + return true +} +func (this *AllTypesOneOf_Field10) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field10) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field10 != that1.Field10 { + return false + } + return true +} +func (this *AllTypesOneOf_Field11) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field11) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field11 != that1.Field11 { + return false + } + return true +} +func (this *AllTypesOneOf_Field12) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field12) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field12 != that1.Field12 { + return false + } + return true +} +func (this *AllTypesOneOf_Field13) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field13) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field13 != that1.Field13 { + return false + } + return true +} +func (this *AllTypesOneOf_Field14) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field14) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field14 != that1.Field14 { + return false + } + return true +} +func (this *AllTypesOneOf_Field15) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_Field15) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + return true +} +func (this *AllTypesOneOf_SubMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllTypesOneOf_SubMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage.Equal(that1.SubMessage) { + return false + } + return true +} +func (this *TwoOneofs) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofsbut is not nil && this == nil") + } + if that1.One == nil { + if this.One != nil { + return fmt.Errorf("this.One != nil && that1.One == nil") + } + } else if this.One == nil { + return fmt.Errorf("this.One == nil && that1.One != nil") + } else if err := this.One.VerboseEqual(that1.One); err != nil { + return err + } + if that1.Two == nil { + if this.Two != nil { + return fmt.Errorf("this.Two != nil && that1.Two == nil") + } + } else if this.Two == nil { + return fmt.Errorf("this.Two == nil && that1.Two != nil") + } else if err := this.Two.VerboseEqual(that1.Two); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *TwoOneofs_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field1) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *TwoOneofs_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field2) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *TwoOneofs_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field3) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *TwoOneofs_Field34) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field34) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field34") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field34 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field34but is not nil && this == nil") + } + if this.Field34 != that1.Field34 { + return fmt.Errorf("Field34 this(%v) Not Equal that(%v)", this.Field34, that1.Field34) + } + return nil +} +func (this *TwoOneofs_Field35) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_Field35) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_Field35") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_Field35 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_Field35but is not nil && this == nil") + } + if !bytes.Equal(this.Field35, that1.Field35) { + return fmt.Errorf("Field35 this(%v) Not Equal that(%v)", this.Field35, that1.Field35) + } + return nil +} +func (this *TwoOneofs_SubMessage2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*TwoOneofs_SubMessage2) + if !ok { + return fmt.Errorf("that is not of type *TwoOneofs_SubMessage2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *TwoOneofs_SubMessage2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *TwoOneofs_SubMessage2but is not nil && this == nil") + } + if !this.SubMessage2.Equal(that1.SubMessage2) { + return fmt.Errorf("SubMessage2 this(%v) Not Equal that(%v)", this.SubMessage2, that1.SubMessage2) + } + return nil +} +func (this *TwoOneofs) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.One == nil { + if this.One != nil { + return false + } + } else if this.One == nil { + return false + } else if !this.One.Equal(that1.One) { + return false + } + if that1.Two == nil { + if this.Two != nil { + return false + } + } else if this.Two == nil { + return false + } else if !this.Two.Equal(that1.Two) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *TwoOneofs_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *TwoOneofs_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *TwoOneofs_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *TwoOneofs_Field34) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field34) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field34 != that1.Field34 { + return false + } + return true +} +func (this *TwoOneofs_Field35) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_Field35) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field35, that1.Field35) { + return false + } + return true +} +func (this *TwoOneofs_SubMessage2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*TwoOneofs_SubMessage2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage2.Equal(that1.SubMessage2) { + return false + } + return true +} +func (this *CustomOneof) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneofbut is not nil && this == nil") + } + if that1.Custom == nil { + if this.Custom != nil { + return fmt.Errorf("this.Custom != nil && that1.Custom == nil") + } + } else if this.Custom == nil { + return fmt.Errorf("this.Custom == nil && that1.Custom != nil") + } else if err := this.Custom.VerboseEqual(that1.Custom); err != nil { + return err + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomOneof_Stringy) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_Stringy) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_Stringy") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_Stringy but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_Stringybut is not nil && this == nil") + } + if this.Stringy != that1.Stringy { + return fmt.Errorf("Stringy this(%v) Not Equal that(%v)", this.Stringy, that1.Stringy) + } + return nil +} +func (this *CustomOneof_CustomType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_CustomType) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_CustomType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_CustomType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_CustomTypebut is not nil && this == nil") + } + if !this.CustomType.Equal(that1.CustomType) { + return fmt.Errorf("CustomType this(%v) Not Equal that(%v)", this.CustomType, that1.CustomType) + } + return nil +} +func (this *CustomOneof_CastType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_CastType) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_CastType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_CastType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_CastTypebut is not nil && this == nil") + } + if this.CastType != that1.CastType { + return fmt.Errorf("CastType this(%v) Not Equal that(%v)", this.CastType, that1.CastType) + } + return nil +} +func (this *CustomOneof_MyCustomName) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomOneof_MyCustomName) + if !ok { + return fmt.Errorf("that is not of type *CustomOneof_MyCustomName") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomOneof_MyCustomName but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomOneof_MyCustomNamebut is not nil && this == nil") + } + if this.MyCustomName != that1.MyCustomName { + return fmt.Errorf("MyCustomName this(%v) Not Equal that(%v)", this.MyCustomName, that1.MyCustomName) + } + return nil +} +func (this *CustomOneof) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Custom == nil { + if this.Custom != nil { + return false + } + } else if this.Custom == nil { + return false + } else if !this.Custom.Equal(that1.Custom) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomOneof_Stringy) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_Stringy) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Stringy != that1.Stringy { + return false + } + return true +} +func (this *CustomOneof_CustomType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_CustomType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.CustomType.Equal(that1.CustomType) { + return false + } + return true +} +func (this *CustomOneof_CastType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_CastType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.CastType != that1.CastType { + return false + } + return true +} +func (this *CustomOneof_MyCustomName) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomOneof_MyCustomName) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.MyCustomName != that1.MyCustomName { + return false + } + return true +} +func (this *Subby) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&one.Subby{") + if this.Sub != nil { + s = append(s, "Sub: "+valueToGoStringOne(this.Sub, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllTypesOneOf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 20) + s = append(s, "&one.AllTypesOneOf{") + if this.TestOneof != nil { + s = append(s, "TestOneof: "+fmt.Sprintf("%#v", this.TestOneof)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllTypesOneOf_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field4) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field4{` + + `Field4:` + fmt.Sprintf("%#v", this.Field4) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field5) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field5{` + + `Field5:` + fmt.Sprintf("%#v", this.Field5) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field6) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field6{` + + `Field6:` + fmt.Sprintf("%#v", this.Field6) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field7) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field7{` + + `Field7:` + fmt.Sprintf("%#v", this.Field7) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field8) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field8{` + + `Field8:` + fmt.Sprintf("%#v", this.Field8) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field9) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field9{` + + `Field9:` + fmt.Sprintf("%#v", this.Field9) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field10) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field10{` + + `Field10:` + fmt.Sprintf("%#v", this.Field10) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field11) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field11{` + + `Field11:` + fmt.Sprintf("%#v", this.Field11) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field12) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field12{` + + `Field12:` + fmt.Sprintf("%#v", this.Field12) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field13) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field13{` + + `Field13:` + fmt.Sprintf("%#v", this.Field13) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field14) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field14{` + + `Field14:` + fmt.Sprintf("%#v", this.Field14) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_Field15) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_Field15{` + + `Field15:` + fmt.Sprintf("%#v", this.Field15) + `}`}, ", ") + return s +} +func (this *AllTypesOneOf_SubMessage) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.AllTypesOneOf_SubMessage{` + + `SubMessage:` + fmt.Sprintf("%#v", this.SubMessage) + `}`}, ", ") + return s +} +func (this *TwoOneofs) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 10) + s = append(s, "&one.TwoOneofs{") + if this.One != nil { + s = append(s, "One: "+fmt.Sprintf("%#v", this.One)+",\n") + } + if this.Two != nil { + s = append(s, "Two: "+fmt.Sprintf("%#v", this.Two)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *TwoOneofs_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field34) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field34{` + + `Field34:` + fmt.Sprintf("%#v", this.Field34) + `}`}, ", ") + return s +} +func (this *TwoOneofs_Field35) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_Field35{` + + `Field35:` + fmt.Sprintf("%#v", this.Field35) + `}`}, ", ") + return s +} +func (this *TwoOneofs_SubMessage2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.TwoOneofs_SubMessage2{` + + `SubMessage2:` + fmt.Sprintf("%#v", this.SubMessage2) + `}`}, ", ") + return s +} +func (this *CustomOneof) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&one.CustomOneof{") + if this.Custom != nil { + s = append(s, "Custom: "+fmt.Sprintf("%#v", this.Custom)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomOneof_Stringy) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_Stringy{` + + `Stringy:` + fmt.Sprintf("%#v", this.Stringy) + `}`}, ", ") + return s +} +func (this *CustomOneof_CustomType) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_CustomType{` + + `CustomType:` + fmt.Sprintf("%#v", this.CustomType) + `}`}, ", ") + return s +} +func (this *CustomOneof_CastType) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_CastType{` + + `CastType:` + fmt.Sprintf("%#v", this.CastType) + `}`}, ", ") + return s +} +func (this *CustomOneof_MyCustomName) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.CustomOneof_MyCustomName{` + + `MyCustomName:` + fmt.Sprintf("%#v", this.MyCustomName) + `}`}, ", ") + return s +} +func valueToGoStringOne(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringOne(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedSubby(r randyOne, easy bool) *Subby { + this := &Subby{} + if r.Intn(10) != 0 { + v1 := randStringOne(r) + this.Sub = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 2) + } + return this +} + +func NewPopulatedAllTypesOneOf(r randyOne, easy bool) *AllTypesOneOf { + this := &AllTypesOneOf{} + oneofNumber_TestOneof := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}[r.Intn(16)] + switch oneofNumber_TestOneof { + case 1: + this.TestOneof = NewPopulatedAllTypesOneOf_Field1(r, easy) + case 2: + this.TestOneof = NewPopulatedAllTypesOneOf_Field2(r, easy) + case 3: + this.TestOneof = NewPopulatedAllTypesOneOf_Field3(r, easy) + case 4: + this.TestOneof = NewPopulatedAllTypesOneOf_Field4(r, easy) + case 5: + this.TestOneof = NewPopulatedAllTypesOneOf_Field5(r, easy) + case 6: + this.TestOneof = NewPopulatedAllTypesOneOf_Field6(r, easy) + case 7: + this.TestOneof = NewPopulatedAllTypesOneOf_Field7(r, easy) + case 8: + this.TestOneof = NewPopulatedAllTypesOneOf_Field8(r, easy) + case 9: + this.TestOneof = NewPopulatedAllTypesOneOf_Field9(r, easy) + case 10: + this.TestOneof = NewPopulatedAllTypesOneOf_Field10(r, easy) + case 11: + this.TestOneof = NewPopulatedAllTypesOneOf_Field11(r, easy) + case 12: + this.TestOneof = NewPopulatedAllTypesOneOf_Field12(r, easy) + case 13: + this.TestOneof = NewPopulatedAllTypesOneOf_Field13(r, easy) + case 14: + this.TestOneof = NewPopulatedAllTypesOneOf_Field14(r, easy) + case 15: + this.TestOneof = NewPopulatedAllTypesOneOf_Field15(r, easy) + case 16: + this.TestOneof = NewPopulatedAllTypesOneOf_SubMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 17) + } + return this +} + +func NewPopulatedAllTypesOneOf_Field1(r randyOne, easy bool) *AllTypesOneOf_Field1 { + this := &AllTypesOneOf_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field2(r randyOne, easy bool) *AllTypesOneOf_Field2 { + this := &AllTypesOneOf_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field3(r randyOne, easy bool) *AllTypesOneOf_Field3 { + this := &AllTypesOneOf_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field4(r randyOne, easy bool) *AllTypesOneOf_Field4 { + this := &AllTypesOneOf_Field4{} + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field5(r randyOne, easy bool) *AllTypesOneOf_Field5 { + this := &AllTypesOneOf_Field5{} + this.Field5 = uint32(r.Uint32()) + return this +} +func NewPopulatedAllTypesOneOf_Field6(r randyOne, easy bool) *AllTypesOneOf_Field6 { + this := &AllTypesOneOf_Field6{} + this.Field6 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedAllTypesOneOf_Field7(r randyOne, easy bool) *AllTypesOneOf_Field7 { + this := &AllTypesOneOf_Field7{} + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field8(r randyOne, easy bool) *AllTypesOneOf_Field8 { + this := &AllTypesOneOf_Field8{} + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field9(r randyOne, easy bool) *AllTypesOneOf_Field9 { + this := &AllTypesOneOf_Field9{} + this.Field9 = uint32(r.Uint32()) + return this +} +func NewPopulatedAllTypesOneOf_Field10(r randyOne, easy bool) *AllTypesOneOf_Field10 { + this := &AllTypesOneOf_Field10{} + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field11(r randyOne, easy bool) *AllTypesOneOf_Field11 { + this := &AllTypesOneOf_Field11{} + this.Field11 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedAllTypesOneOf_Field12(r randyOne, easy bool) *AllTypesOneOf_Field12 { + this := &AllTypesOneOf_Field12{} + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + return this +} +func NewPopulatedAllTypesOneOf_Field13(r randyOne, easy bool) *AllTypesOneOf_Field13 { + this := &AllTypesOneOf_Field13{} + this.Field13 = bool(bool(r.Intn(2) == 0)) + return this +} +func NewPopulatedAllTypesOneOf_Field14(r randyOne, easy bool) *AllTypesOneOf_Field14 { + this := &AllTypesOneOf_Field14{} + this.Field14 = randStringOne(r) + return this +} +func NewPopulatedAllTypesOneOf_Field15(r randyOne, easy bool) *AllTypesOneOf_Field15 { + this := &AllTypesOneOf_Field15{} + v2 := r.Intn(100) + this.Field15 = make([]byte, v2) + for i := 0; i < v2; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedAllTypesOneOf_SubMessage(r randyOne, easy bool) *AllTypesOneOf_SubMessage { + this := &AllTypesOneOf_SubMessage{} + this.SubMessage = NewPopulatedSubby(r, easy) + return this +} +func NewPopulatedTwoOneofs(r randyOne, easy bool) *TwoOneofs { + this := &TwoOneofs{} + oneofNumber_One := []int32{1, 2, 3}[r.Intn(3)] + switch oneofNumber_One { + case 1: + this.One = NewPopulatedTwoOneofs_Field1(r, easy) + case 2: + this.One = NewPopulatedTwoOneofs_Field2(r, easy) + case 3: + this.One = NewPopulatedTwoOneofs_Field3(r, easy) + } + oneofNumber_Two := []int32{34, 35, 36}[r.Intn(3)] + switch oneofNumber_Two { + case 34: + this.Two = NewPopulatedTwoOneofs_Field34(r, easy) + case 35: + this.Two = NewPopulatedTwoOneofs_Field35(r, easy) + case 36: + this.Two = NewPopulatedTwoOneofs_SubMessage2(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 37) + } + return this +} + +func NewPopulatedTwoOneofs_Field1(r randyOne, easy bool) *TwoOneofs_Field1 { + this := &TwoOneofs_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field2(r randyOne, easy bool) *TwoOneofs_Field2 { + this := &TwoOneofs_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field3(r randyOne, easy bool) *TwoOneofs_Field3 { + this := &TwoOneofs_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedTwoOneofs_Field34(r randyOne, easy bool) *TwoOneofs_Field34 { + this := &TwoOneofs_Field34{} + this.Field34 = randStringOne(r) + return this +} +func NewPopulatedTwoOneofs_Field35(r randyOne, easy bool) *TwoOneofs_Field35 { + this := &TwoOneofs_Field35{} + v3 := r.Intn(100) + this.Field35 = make([]byte, v3) + for i := 0; i < v3; i++ { + this.Field35[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedTwoOneofs_SubMessage2(r randyOne, easy bool) *TwoOneofs_SubMessage2 { + this := &TwoOneofs_SubMessage2{} + this.SubMessage2 = NewPopulatedSubby(r, easy) + return this +} +func NewPopulatedCustomOneof(r randyOne, easy bool) *CustomOneof { + this := &CustomOneof{} + oneofNumber_Custom := []int32{34, 35, 36, 37}[r.Intn(4)] + switch oneofNumber_Custom { + case 34: + this.Custom = NewPopulatedCustomOneof_Stringy(r, easy) + case 35: + this.Custom = NewPopulatedCustomOneof_CustomType(r, easy) + case 36: + this.Custom = NewPopulatedCustomOneof_CastType(r, easy) + case 37: + this.Custom = NewPopulatedCustomOneof_MyCustomName(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedOne(r, 38) + } + return this +} + +func NewPopulatedCustomOneof_Stringy(r randyOne, easy bool) *CustomOneof_Stringy { + this := &CustomOneof_Stringy{} + this.Stringy = randStringOne(r) + return this +} +func NewPopulatedCustomOneof_CustomType(r randyOne, easy bool) *CustomOneof_CustomType { + this := &CustomOneof_CustomType{} + v4 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.CustomType = *v4 + return this +} +func NewPopulatedCustomOneof_CastType(r randyOne, easy bool) *CustomOneof_CastType { + this := &CustomOneof_CastType{} + this.CastType = github_com_gogo_protobuf_test_casttype.MyUint64Type(uint64(r.Uint32())) + return this +} +func NewPopulatedCustomOneof_MyCustomName(r randyOne, easy bool) *CustomOneof_MyCustomName { + this := &CustomOneof_MyCustomName{} + this.MyCustomName = int64(r.Int63()) + if r.Intn(2) == 0 { + this.MyCustomName *= -1 + } + return this +} + +type randyOne interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneOne(r randyOne) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringOne(r randyOne) string { + v5 := r.Intn(100) + tmps := make([]rune, v5) + for i := 0; i < v5; i++ { + tmps[i] = randUTF8RuneOne(r) + } + return string(tmps) +} +func randUnrecognizedOne(r randyOne, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldOne(data, r, fieldNumber, wire) + } + return data +} +func randFieldOne(data []byte, r randyOne, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateOne(data, uint64(key)) + v6 := r.Int63() + if r.Intn(2) == 0 { + v6 *= -1 + } + data = encodeVarintPopulateOne(data, uint64(v6)) + case 1: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateOne(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateOne(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateOne(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Subby) Size() (n int) { + var l int + _ = l + if m.Sub != nil { + l = len(*m.Sub) + n += 1 + l + sovOne(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllTypesOneOf) Size() (n int) { + var l int + _ = l + if m.TestOneof != nil { + n += m.TestOneof.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AllTypesOneOf_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *AllTypesOneOf_Field4) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field4)) + return n +} +func (m *AllTypesOneOf_Field5) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field5)) + return n +} +func (m *AllTypesOneOf_Field6) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field6)) + return n +} +func (m *AllTypesOneOf_Field7) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field7)) + return n +} +func (m *AllTypesOneOf_Field8) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field8)) + return n +} +func (m *AllTypesOneOf_Field9) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field10) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *AllTypesOneOf_Field11) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field12) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *AllTypesOneOf_Field13) Size() (n int) { + var l int + _ = l + n += 2 + return n +} +func (m *AllTypesOneOf_Field14) Size() (n int) { + var l int + _ = l + l = len(m.Field14) + n += 1 + l + sovOne(uint64(l)) + return n +} +func (m *AllTypesOneOf_Field15) Size() (n int) { + var l int + _ = l + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovOne(uint64(l)) + } + return n +} +func (m *AllTypesOneOf_SubMessage) Size() (n int) { + var l int + _ = l + if m.SubMessage != nil { + l = m.SubMessage.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *TwoOneofs) Size() (n int) { + var l int + _ = l + if m.One != nil { + n += m.One.Size() + } + if m.Two != nil { + n += m.Two.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *TwoOneofs_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *TwoOneofs_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *TwoOneofs_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *TwoOneofs_Field34) Size() (n int) { + var l int + _ = l + l = len(m.Field34) + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *TwoOneofs_Field35) Size() (n int) { + var l int + _ = l + if m.Field35 != nil { + l = len(m.Field35) + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *TwoOneofs_SubMessage2) Size() (n int) { + var l int + _ = l + if m.SubMessage2 != nil { + l = m.SubMessage2.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} +func (m *CustomOneof) Size() (n int) { + var l int + _ = l + if m.Custom != nil { + n += m.Custom.Size() + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomOneof_Stringy) Size() (n int) { + var l int + _ = l + l = len(m.Stringy) + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *CustomOneof_CustomType) Size() (n int) { + var l int + _ = l + l = m.CustomType.Size() + n += 2 + l + sovOne(uint64(l)) + return n +} +func (m *CustomOneof_CastType) Size() (n int) { + var l int + _ = l + n += 2 + sovOne(uint64(m.CastType)) + return n +} +func (m *CustomOneof_MyCustomName) Size() (n int) { + var l int + _ = l + n += 2 + sovOne(uint64(m.MyCustomName)) + return n +} + +func sovOne(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozOne(x uint64) (n int) { + return sovOne(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Subby) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Subby{`, + `Sub:` + valueToStringOne(this.Sub) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf{`, + `TestOneof:` + fmt.Sprintf("%v", this.TestOneof) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field4) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field4{`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field5) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field5{`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field6) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field6{`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field7) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field7{`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field8) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field8{`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field9) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field9{`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field10) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field10{`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field11) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field11{`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field12) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field12{`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field13) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field13{`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field14) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field14{`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_Field15) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_Field15{`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `}`, + }, "") + return s +} +func (this *AllTypesOneOf_SubMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AllTypesOneOf_SubMessage{`, + `SubMessage:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs{`, + `One:` + fmt.Sprintf("%v", this.One) + `,`, + `Two:` + fmt.Sprintf("%v", this.Two) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field34) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field34{`, + `Field34:` + fmt.Sprintf("%v", this.Field34) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_Field35) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_Field35{`, + `Field35:` + fmt.Sprintf("%v", this.Field35) + `,`, + `}`, + }, "") + return s +} +func (this *TwoOneofs_SubMessage2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TwoOneofs_SubMessage2{`, + `SubMessage2:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage2), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof{`, + `Custom:` + fmt.Sprintf("%v", this.Custom) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_Stringy) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_Stringy{`, + `Stringy:` + fmt.Sprintf("%v", this.Stringy) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_CustomType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_CustomType{`, + `CustomType:` + fmt.Sprintf("%v", this.CustomType) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_CastType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_CastType{`, + `CastType:` + fmt.Sprintf("%v", this.CastType) + `,`, + `}`, + }, "") + return s +} +func (this *CustomOneof_MyCustomName) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomOneof_MyCustomName{`, + `MyCustomName:` + fmt.Sprintf("%v", this.MyCustomName) + `,`, + `}`, + }, "") + return s +} +func valueToStringOne(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Subby) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Subby: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Subby: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sub", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Sub = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOneUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOneUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AllTypesOneOf) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AllTypesOneOf: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AllTypesOneOf: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.TestOneof = &AllTypesOneOf_Field1{v} + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.TestOneof = &AllTypesOneOf_Field2{v} + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &AllTypesOneOf_Field3{v} + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &AllTypesOneOf_Field4{v} + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &AllTypesOneOf_Field5{v} + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &AllTypesOneOf_Field6{v} + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.TestOneof = &AllTypesOneOf_Field7{v} + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.TestOneof = &AllTypesOneOf_Field8{int64(v)} + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.TestOneof = &AllTypesOneOf_Field9{v} + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.TestOneof = &AllTypesOneOf_Field10{v} + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.TestOneof = &AllTypesOneOf_Field11{v} + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.TestOneof = &AllTypesOneOf_Field12{v} + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.TestOneof = &AllTypesOneOf_Field13{b} + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TestOneof = &AllTypesOneOf_Field14{string(data[iNdEx:postIndex])} + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := make([]byte, postIndex-iNdEx) + copy(v, data[iNdEx:postIndex]) + m.TestOneof = &AllTypesOneOf_Field15{v} + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &Subby{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.TestOneof = &AllTypesOneOf_SubMessage{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOneUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOneUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TwoOneofs) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TwoOneofs: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TwoOneofs: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.One = &TwoOneofs_Field1{v} + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.One = &TwoOneofs_Field2{v} + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.One = &TwoOneofs_Field3{v} + case 34: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field34", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Two = &TwoOneofs_Field34{string(data[iNdEx:postIndex])} + iNdEx = postIndex + case 35: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field35", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := make([]byte, postIndex-iNdEx) + copy(v, data[iNdEx:postIndex]) + m.Two = &TwoOneofs_Field35{v} + iNdEx = postIndex + case 36: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubMessage2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &Subby{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.Two = &TwoOneofs_SubMessage2{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOneUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOneUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CustomOneof) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CustomOneof: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CustomOneof: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 34: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Stringy", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Custom = &CustomOneof_Stringy{string(data[iNdEx:postIndex])} + iNdEx = postIndex + case 35: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CustomType", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var vv github_com_gogo_protobuf_test_custom.Uint128 + v := &vv + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.Custom = &CustomOneof_CustomType{*v} + iNdEx = postIndex + case 36: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CastType", wireType) + } + var v github_com_gogo_protobuf_test_casttype.MyUint64Type + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (github_com_gogo_protobuf_test_casttype.MyUint64Type(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Custom = &CustomOneof_CastType{v} + case 37: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MyCustomName", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Custom = &CustomOneof_MyCustomName{v} + default: + iNdEx = preIndex + skippy, err := skipOneUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOneUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipOneUnsafe(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthOneUnsafe + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipOneUnsafe(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthOneUnsafe = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowOneUnsafe = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeunmarshaler/one.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeunmarshaler/one.proto new file mode 100644 index 0000000000000000000000000000000000000000..cef2b7f2d50020cfeac054235900061daaad3f09 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeunmarshaler/one.proto @@ -0,0 +1,101 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package one; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = true; + +message Subby { + optional string sub = 1; +} + +message AllTypesOneOf { + oneof test_oneof { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + int64 Field4 = 4; + uint32 Field5 = 5; + uint64 Field6 = 6; + sint32 Field7 = 7; + sint64 Field8 = 8; + fixed32 Field9 = 9; + sfixed32 Field10 = 10; + fixed64 Field11 = 11; + sfixed64 Field12 = 12; + bool Field13 = 13; + string Field14 = 14; + bytes Field15 = 15; + Subby sub_message = 16; + } +} + +message TwoOneofs { + oneof one { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + } + + oneof two { + string Field34 = 34; + bytes Field35 = 35; + Subby sub_message2 = 36; + } +} + +message CustomOneof { + oneof custom { + string Stringy = 34; + bytes CustomType = 35 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; + uint64 CastType = 36 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + int64 CustomName = 37 [(gogoproto.customname) = "MyCustomName"]; + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeunmarshaler/onepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeunmarshaler/onepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..6fe1235f3c081ae24976d093d18439d0cc7b2d44 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/combos/unsafeunmarshaler/onepb_test.go @@ -0,0 +1,632 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeunmarshaler/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/unsafeunmarshaler/one.proto + +It has these top-level messages: + Subby + AllTypesOneOf + TwoOneofs + CustomOneof +*/ +package one + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestSubbyProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAllTypesOneOfProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestTwoOneofsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCustomOneofProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSubbyJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllTypesOneOfJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllTypesOneOf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTwoOneofsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &TwoOneofs{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomOneofJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomOneof{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSubbyProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllTypesOneOfProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTwoOneofsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomOneofProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOneDescription(t *testing.T) { + OneDescription() +} +func TestSubbyVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllTypesOneOfVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllTypesOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTwoOneofsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &TwoOneofs{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomOneofVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomOneof{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSubbyGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllTypesOneOfGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTwoOneofsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomOneofGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSubbySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestAllTypesOneOfSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllTypesOneOf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestTwoOneofsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTwoOneofs(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestCustomOneofSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomOneof(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSubbyStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllTypesOneOfStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllTypesOneOf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTwoOneofsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTwoOneofs(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomOneofStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomOneof(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/doc.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/doc.go new file mode 100644 index 0000000000000000000000000000000000000000..b9f2ff176765e8b51248b7e68acaac00b40edd03 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/doc.go @@ -0,0 +1 @@ +package one diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/one.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/one.proto new file mode 100644 index 0000000000000000000000000000000000000000..0c88ac86a0dfd3c9e4bf2b28891e71487099b328 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof/one.proto @@ -0,0 +1,101 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package one; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Subby { + optional string sub = 1; +} + +message AllTypesOneOf { + oneof test_oneof { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + int64 Field4 = 4; + uint32 Field5 = 5; + uint64 Field6 = 6; + sint32 Field7 = 7; + sint64 Field8 = 8; + fixed32 Field9 = 9; + sfixed32 Field10 = 10; + fixed64 Field11 = 11; + sfixed64 Field12 = 12; + bool Field13 = 13; + string Field14 = 14; + bytes Field15 = 15; + Subby sub_message = 16; + } +} + +message TwoOneofs { + oneof one { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + } + + oneof two { + string Field34 = 34; + bytes Field35 = 35; + Subby sub_message2 = 36; + } +} + +message CustomOneof { + oneof custom { + string Stringy = 34; + bytes CustomType = 35 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; + uint64 CastType = 36 [(gogoproto.casttype) = "github.com/gogo/protobuf/test/casttype.MyUint64Type"]; + int64 CustomName = 37 [(gogoproto.customname) = "MyCustomName"]; + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..70da5300ef037e359026478244403b7c4beafd9a --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/Makefile @@ -0,0 +1,31 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/protobuf/gogoproto +# +# 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. +# +# 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: + go install github.com/gogo/protobuf/protoc-gen-combo + protoc-gen-combo --version="3.0.0" --proto_path=../../../../../:../../protobuf/:. one.proto \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/both/one.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/both/one.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..968501f3919de9980cee2216927a6aa247318df3 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/both/one.pb.go @@ -0,0 +1,4493 @@ +// Code generated by protoc-gen-gogo. +// source: combos/both/one.proto +// DO NOT EDIT! + +/* + Package one is a generated protocol buffer package. + + It is generated from these files: + combos/both/one.proto + + It has these top-level messages: + Subby + SampleOneOf +*/ +package one + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Subby struct { + Sub string `protobuf:"bytes,1,opt,name=sub,proto3" json:"sub,omitempty"` +} + +func (m *Subby) Reset() { *m = Subby{} } +func (*Subby) ProtoMessage() {} + +type SampleOneOf struct { + // Types that are valid to be assigned to TestOneof: + // *SampleOneOf_Field1 + // *SampleOneOf_Field2 + // *SampleOneOf_Field3 + // *SampleOneOf_Field4 + // *SampleOneOf_Field5 + // *SampleOneOf_Field6 + // *SampleOneOf_Field7 + // *SampleOneOf_Field8 + // *SampleOneOf_Field9 + // *SampleOneOf_Field10 + // *SampleOneOf_Field11 + // *SampleOneOf_Field12 + // *SampleOneOf_Field13 + // *SampleOneOf_Field14 + // *SampleOneOf_Field15 + // *SampleOneOf_SubMessage + TestOneof isSampleOneOf_TestOneof `protobuf_oneof:"test_oneof"` +} + +func (m *SampleOneOf) Reset() { *m = SampleOneOf{} } +func (*SampleOneOf) ProtoMessage() {} + +type isSampleOneOf_TestOneof interface { + isSampleOneOf_TestOneof() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} + +type SampleOneOf_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,proto3,oneof"` +} +type SampleOneOf_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,proto3,oneof"` +} +type SampleOneOf_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,proto3,oneof"` +} +type SampleOneOf_Field4 struct { + Field4 int64 `protobuf:"varint,4,opt,name=Field4,proto3,oneof"` +} +type SampleOneOf_Field5 struct { + Field5 uint32 `protobuf:"varint,5,opt,name=Field5,proto3,oneof"` +} +type SampleOneOf_Field6 struct { + Field6 uint64 `protobuf:"varint,6,opt,name=Field6,proto3,oneof"` +} +type SampleOneOf_Field7 struct { + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7,proto3,oneof"` +} +type SampleOneOf_Field8 struct { + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8,proto3,oneof"` +} +type SampleOneOf_Field9 struct { + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9,proto3,oneof"` +} +type SampleOneOf_Field10 struct { + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10,proto3,oneof"` +} +type SampleOneOf_Field11 struct { + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11,proto3,oneof"` +} +type SampleOneOf_Field12 struct { + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12,proto3,oneof"` +} +type SampleOneOf_Field13 struct { + Field13 bool `protobuf:"varint,13,opt,name=Field13,proto3,oneof"` +} +type SampleOneOf_Field14 struct { + Field14 string `protobuf:"bytes,14,opt,name=Field14,proto3,oneof"` +} +type SampleOneOf_Field15 struct { + Field15 []byte `protobuf:"bytes,15,opt,name=Field15,proto3,oneof"` +} +type SampleOneOf_SubMessage struct { + SubMessage *Subby `protobuf:"bytes,16,opt,name=sub_message,oneof"` +} + +func (*SampleOneOf_Field1) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field2) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field3) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field4) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field5) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field6) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field7) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field8) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field9) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field10) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field11) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field12) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field13) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field14) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field15) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_SubMessage) isSampleOneOf_TestOneof() {} + +func (m *SampleOneOf) GetTestOneof() isSampleOneOf_TestOneof { + if m != nil { + return m.TestOneof + } + return nil +} + +func (m *SampleOneOf) GetField1() float64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *SampleOneOf) GetField2() float32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *SampleOneOf) GetField3() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *SampleOneOf) GetField4() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field4); ok { + return x.Field4 + } + return 0 +} + +func (m *SampleOneOf) GetField5() uint32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field5); ok { + return x.Field5 + } + return 0 +} + +func (m *SampleOneOf) GetField6() uint64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field6); ok { + return x.Field6 + } + return 0 +} + +func (m *SampleOneOf) GetField7() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field7); ok { + return x.Field7 + } + return 0 +} + +func (m *SampleOneOf) GetField8() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field8); ok { + return x.Field8 + } + return 0 +} + +func (m *SampleOneOf) GetField9() uint32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field9); ok { + return x.Field9 + } + return 0 +} + +func (m *SampleOneOf) GetField10() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field10); ok { + return x.Field10 + } + return 0 +} + +func (m *SampleOneOf) GetField11() uint64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field11); ok { + return x.Field11 + } + return 0 +} + +func (m *SampleOneOf) GetField12() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field12); ok { + return x.Field12 + } + return 0 +} + +func (m *SampleOneOf) GetField13() bool { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field13); ok { + return x.Field13 + } + return false +} + +func (m *SampleOneOf) GetField14() string { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field14); ok { + return x.Field14 + } + return "" +} + +func (m *SampleOneOf) GetField15() []byte { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field15); ok { + return x.Field15 + } + return nil +} + +func (m *SampleOneOf) GetSubMessage() *Subby { + if x, ok := m.GetTestOneof().(*SampleOneOf_SubMessage); ok { + return x.SubMessage + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*SampleOneOf) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _SampleOneOf_OneofMarshaler, _SampleOneOf_OneofUnmarshaler, []interface{}{ + (*SampleOneOf_Field1)(nil), + (*SampleOneOf_Field2)(nil), + (*SampleOneOf_Field3)(nil), + (*SampleOneOf_Field4)(nil), + (*SampleOneOf_Field5)(nil), + (*SampleOneOf_Field6)(nil), + (*SampleOneOf_Field7)(nil), + (*SampleOneOf_Field8)(nil), + (*SampleOneOf_Field9)(nil), + (*SampleOneOf_Field10)(nil), + (*SampleOneOf_Field11)(nil), + (*SampleOneOf_Field12)(nil), + (*SampleOneOf_Field13)(nil), + (*SampleOneOf_Field14)(nil), + (*SampleOneOf_Field15)(nil), + (*SampleOneOf_SubMessage)(nil), + } +} + +func _SampleOneOf_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*SampleOneOf) + // test_oneof + switch x := m.TestOneof.(type) { + case *SampleOneOf_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *SampleOneOf_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *SampleOneOf_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case *SampleOneOf_Field4: + _ = b.EncodeVarint(4<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field4)) + case *SampleOneOf_Field5: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field5)) + case *SampleOneOf_Field6: + _ = b.EncodeVarint(6<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field6)) + case *SampleOneOf_Field7: + _ = b.EncodeVarint(7<<3 | proto.WireVarint) + _ = b.EncodeZigzag32(uint64(x.Field7)) + case *SampleOneOf_Field8: + _ = b.EncodeVarint(8<<3 | proto.WireVarint) + _ = b.EncodeZigzag64(uint64(x.Field8)) + case *SampleOneOf_Field9: + _ = b.EncodeVarint(9<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field9)) + case *SampleOneOf_Field10: + _ = b.EncodeVarint(10<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field10)) + case *SampleOneOf_Field11: + _ = b.EncodeVarint(11<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field11)) + case *SampleOneOf_Field12: + _ = b.EncodeVarint(12<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field12)) + case *SampleOneOf_Field13: + t := uint64(0) + if x.Field13 { + t = 1 + } + _ = b.EncodeVarint(13<<3 | proto.WireVarint) + _ = b.EncodeVarint(t) + case *SampleOneOf_Field14: + _ = b.EncodeVarint(14<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field14) + case *SampleOneOf_Field15: + _ = b.EncodeVarint(15<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field15) + case *SampleOneOf_SubMessage: + _ = b.EncodeVarint(16<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("SampleOneOf.TestOneof has unexpected type %T", x) + } + return nil +} + +func _SampleOneOf_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*SampleOneOf) + switch tag { + case 1: // test_oneof.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field1{math.Float64frombits(x)} + return true, err + case 2: // test_oneof.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // test_oneof.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field3{int32(x)} + return true, err + case 4: // test_oneof.Field4 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field4{int64(x)} + return true, err + case 5: // test_oneof.Field5 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field5{uint32(x)} + return true, err + case 6: // test_oneof.Field6 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field6{x} + return true, err + case 7: // test_oneof.Field7 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag32() + m.TestOneof = &SampleOneOf_Field7{int32(x)} + return true, err + case 8: // test_oneof.Field8 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag64() + m.TestOneof = &SampleOneOf_Field8{int64(x)} + return true, err + case 9: // test_oneof.Field9 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field9{uint32(x)} + return true, err + case 10: // test_oneof.Field10 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field10{int32(x)} + return true, err + case 11: // test_oneof.Field11 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field11{x} + return true, err + case 12: // test_oneof.Field12 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field12{int64(x)} + return true, err + case 13: // test_oneof.Field13 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field13{x != 0} + return true, err + case 14: // test_oneof.Field14 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.TestOneof = &SampleOneOf_Field14{x} + return true, err + case 15: // test_oneof.Field15 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.TestOneof = &SampleOneOf_Field15{x} + return true, err + case 16: // test_oneof.sub_message + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.TestOneof = &SampleOneOf_SubMessage{msg} + return true, err + default: + return false, nil + } +} + +func (this *Subby) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *SampleOneOf) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func OneDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/both/one.proto"), + Package: func(v string) *string { return &v }("one"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Subby"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("sub"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("SampleOneOf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("sub_message"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(0), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("test_oneof")}}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + Syntax: func(v string) *string { return &v }("proto3"), + }}, + } +} +func (this *Subby) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Subby) + if !ok { + return fmt.Errorf("that is not of type *Subby") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Subby but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Subbybut is not nil && this == nil") + } + if this.Sub != that1.Sub { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) + } + return nil +} +func (this *Subby) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Subby) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Sub != that1.Sub { + return false + } + return true +} +func (this *SampleOneOf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOfbut is not nil && this == nil") + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return fmt.Errorf("this.TestOneof != nil && that1.TestOneof == nil") + } + } else if this.TestOneof == nil { + return fmt.Errorf("this.TestOneof == nil && that1.TestOneof != nil") + } else if err := this.TestOneof.VerboseEqual(that1.TestOneof); err != nil { + return err + } + return nil +} +func (this *SampleOneOf_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field1) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *SampleOneOf_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field2) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *SampleOneOf_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field3) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *SampleOneOf_Field4) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field4) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field4") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field4 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field4but is not nil && this == nil") + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + return nil +} +func (this *SampleOneOf_Field5) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field5) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field5") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field5 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field5but is not nil && this == nil") + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + return nil +} +func (this *SampleOneOf_Field6) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field6) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field6") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field6 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field6but is not nil && this == nil") + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + return nil +} +func (this *SampleOneOf_Field7) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field7) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field7") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field7 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field7but is not nil && this == nil") + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + return nil +} +func (this *SampleOneOf_Field8) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field8) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field8") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field8 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field8but is not nil && this == nil") + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + return nil +} +func (this *SampleOneOf_Field9) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field9) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field9") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field9 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field9but is not nil && this == nil") + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + return nil +} +func (this *SampleOneOf_Field10) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field10) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field10") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field10 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field10but is not nil && this == nil") + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + return nil +} +func (this *SampleOneOf_Field11) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field11) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field11") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field11 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field11but is not nil && this == nil") + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + return nil +} +func (this *SampleOneOf_Field12) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field12) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field12") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field12 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field12but is not nil && this == nil") + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + return nil +} +func (this *SampleOneOf_Field13) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field13) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field13") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field13 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field13but is not nil && this == nil") + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + return nil +} +func (this *SampleOneOf_Field14) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field14) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field14") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field14 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field14but is not nil && this == nil") + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + return nil +} +func (this *SampleOneOf_Field15) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field15) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field15") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field15 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field15but is not nil && this == nil") + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + return nil +} +func (this *SampleOneOf_SubMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_SubMessage) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_SubMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_SubMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_SubMessagebut is not nil && this == nil") + } + if !this.SubMessage.Equal(that1.SubMessage) { + return fmt.Errorf("SubMessage this(%v) Not Equal that(%v)", this.SubMessage, that1.SubMessage) + } + return nil +} +func (this *SampleOneOf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return false + } + } else if this.TestOneof == nil { + return false + } else if !this.TestOneof.Equal(that1.TestOneof) { + return false + } + return true +} +func (this *SampleOneOf_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *SampleOneOf_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *SampleOneOf_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *SampleOneOf_Field4) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field4) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field4 != that1.Field4 { + return false + } + return true +} +func (this *SampleOneOf_Field5) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field5) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field5 != that1.Field5 { + return false + } + return true +} +func (this *SampleOneOf_Field6) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field6) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field6 != that1.Field6 { + return false + } + return true +} +func (this *SampleOneOf_Field7) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field7) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field7 != that1.Field7 { + return false + } + return true +} +func (this *SampleOneOf_Field8) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field8) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field8 != that1.Field8 { + return false + } + return true +} +func (this *SampleOneOf_Field9) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field9) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field9 != that1.Field9 { + return false + } + return true +} +func (this *SampleOneOf_Field10) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field10) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field10 != that1.Field10 { + return false + } + return true +} +func (this *SampleOneOf_Field11) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field11) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field11 != that1.Field11 { + return false + } + return true +} +func (this *SampleOneOf_Field12) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field12) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field12 != that1.Field12 { + return false + } + return true +} +func (this *SampleOneOf_Field13) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field13) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field13 != that1.Field13 { + return false + } + return true +} +func (this *SampleOneOf_Field14) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field14) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field14 != that1.Field14 { + return false + } + return true +} +func (this *SampleOneOf_Field15) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field15) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + return true +} +func (this *SampleOneOf_SubMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_SubMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage.Equal(that1.SubMessage) { + return false + } + return true +} +func (this *Subby) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&one.Subby{") + s = append(s, "Sub: "+fmt.Sprintf("%#v", this.Sub)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SampleOneOf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 20) + s = append(s, "&one.SampleOneOf{") + if this.TestOneof != nil { + s = append(s, "TestOneof: "+fmt.Sprintf("%#v", this.TestOneof)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SampleOneOf_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field4) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field4{` + + `Field4:` + fmt.Sprintf("%#v", this.Field4) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field5) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field5{` + + `Field5:` + fmt.Sprintf("%#v", this.Field5) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field6) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field6{` + + `Field6:` + fmt.Sprintf("%#v", this.Field6) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field7) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field7{` + + `Field7:` + fmt.Sprintf("%#v", this.Field7) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field8) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field8{` + + `Field8:` + fmt.Sprintf("%#v", this.Field8) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field9) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field9{` + + `Field9:` + fmt.Sprintf("%#v", this.Field9) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field10) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field10{` + + `Field10:` + fmt.Sprintf("%#v", this.Field10) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field11) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field11{` + + `Field11:` + fmt.Sprintf("%#v", this.Field11) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field12) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field12{` + + `Field12:` + fmt.Sprintf("%#v", this.Field12) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field13) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field13{` + + `Field13:` + fmt.Sprintf("%#v", this.Field13) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field14) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field14{` + + `Field14:` + fmt.Sprintf("%#v", this.Field14) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field15) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field15{` + + `Field15:` + fmt.Sprintf("%#v", this.Field15) + `}`}, ", ") + return s +} +func (this *SampleOneOf_SubMessage) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_SubMessage{` + + `SubMessage:` + fmt.Sprintf("%#v", this.SubMessage) + `}`}, ", ") + return s +} +func valueToGoStringOne(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringOne(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *Subby) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Subby) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Sub) > 0 { + data[i] = 0xa + i++ + i = encodeVarintOne(data, i, uint64(len(m.Sub))) + i += copy(data[i:], m.Sub) + } + return i, nil +} + +func (m *SampleOneOf) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *SampleOneOf) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.TestOneof != nil { + nn1, err := m.TestOneof.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn1 + } + return i, nil +} + +func (m *SampleOneOf_Field1) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x9 + i++ + i = encodeFixed64One(data, i, uint64(math.Float64bits(m.Field1))) + return i, nil +} +func (m *SampleOneOf_Field2) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x15 + i++ + i = encodeFixed32One(data, i, uint32(math.Float32bits(m.Field2))) + return i, nil +} +func (m *SampleOneOf_Field3) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x18 + i++ + i = encodeVarintOne(data, i, uint64(m.Field3)) + return i, nil +} +func (m *SampleOneOf_Field4) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x20 + i++ + i = encodeVarintOne(data, i, uint64(m.Field4)) + return i, nil +} +func (m *SampleOneOf_Field5) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x28 + i++ + i = encodeVarintOne(data, i, uint64(m.Field5)) + return i, nil +} +func (m *SampleOneOf_Field6) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x30 + i++ + i = encodeVarintOne(data, i, uint64(m.Field6)) + return i, nil +} +func (m *SampleOneOf_Field7) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x38 + i++ + i = encodeVarintOne(data, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31)))) + return i, nil +} +func (m *SampleOneOf_Field8) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x40 + i++ + i = encodeVarintOne(data, i, uint64((uint64(m.Field8)<<1)^uint64((m.Field8>>63)))) + return i, nil +} +func (m *SampleOneOf_Field9) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x4d + i++ + i = encodeFixed32One(data, i, uint32(m.Field9)) + return i, nil +} +func (m *SampleOneOf_Field10) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x55 + i++ + i = encodeFixed32One(data, i, uint32(m.Field10)) + return i, nil +} +func (m *SampleOneOf_Field11) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x59 + i++ + i = encodeFixed64One(data, i, uint64(m.Field11)) + return i, nil +} +func (m *SampleOneOf_Field12) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x61 + i++ + i = encodeFixed64One(data, i, uint64(m.Field12)) + return i, nil +} +func (m *SampleOneOf_Field13) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x68 + i++ + if m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + return i, nil +} +func (m *SampleOneOf_Field14) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x72 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field14))) + i += copy(data[i:], m.Field14) + return i, nil +} +func (m *SampleOneOf_Field15) MarshalTo(data []byte) (int, error) { + i := 0 + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + return i, nil +} +func (m *SampleOneOf_SubMessage) MarshalTo(data []byte) (int, error) { + i := 0 + if m.SubMessage != nil { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + i = encodeVarintOne(data, i, uint64(m.SubMessage.Size())) + n2, err := m.SubMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + } + return i, nil +} +func encodeFixed64One(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32One(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintOne(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedSubby(r randyOne, easy bool) *Subby { + this := &Subby{} + this.Sub = randStringOne(r) + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedSampleOneOf(r randyOne, easy bool) *SampleOneOf { + this := &SampleOneOf{} + oneofNumber_TestOneof := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}[r.Intn(16)] + switch oneofNumber_TestOneof { + case 1: + this.TestOneof = NewPopulatedSampleOneOf_Field1(r, easy) + case 2: + this.TestOneof = NewPopulatedSampleOneOf_Field2(r, easy) + case 3: + this.TestOneof = NewPopulatedSampleOneOf_Field3(r, easy) + case 4: + this.TestOneof = NewPopulatedSampleOneOf_Field4(r, easy) + case 5: + this.TestOneof = NewPopulatedSampleOneOf_Field5(r, easy) + case 6: + this.TestOneof = NewPopulatedSampleOneOf_Field6(r, easy) + case 7: + this.TestOneof = NewPopulatedSampleOneOf_Field7(r, easy) + case 8: + this.TestOneof = NewPopulatedSampleOneOf_Field8(r, easy) + case 9: + this.TestOneof = NewPopulatedSampleOneOf_Field9(r, easy) + case 10: + this.TestOneof = NewPopulatedSampleOneOf_Field10(r, easy) + case 11: + this.TestOneof = NewPopulatedSampleOneOf_Field11(r, easy) + case 12: + this.TestOneof = NewPopulatedSampleOneOf_Field12(r, easy) + case 13: + this.TestOneof = NewPopulatedSampleOneOf_Field13(r, easy) + case 14: + this.TestOneof = NewPopulatedSampleOneOf_Field14(r, easy) + case 15: + this.TestOneof = NewPopulatedSampleOneOf_Field15(r, easy) + case 16: + this.TestOneof = NewPopulatedSampleOneOf_SubMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedSampleOneOf_Field1(r randyOne, easy bool) *SampleOneOf_Field1 { + this := &SampleOneOf_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field2(r randyOne, easy bool) *SampleOneOf_Field2 { + this := &SampleOneOf_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field3(r randyOne, easy bool) *SampleOneOf_Field3 { + this := &SampleOneOf_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field4(r randyOne, easy bool) *SampleOneOf_Field4 { + this := &SampleOneOf_Field4{} + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field5(r randyOne, easy bool) *SampleOneOf_Field5 { + this := &SampleOneOf_Field5{} + this.Field5 = uint32(r.Uint32()) + return this +} +func NewPopulatedSampleOneOf_Field6(r randyOne, easy bool) *SampleOneOf_Field6 { + this := &SampleOneOf_Field6{} + this.Field6 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedSampleOneOf_Field7(r randyOne, easy bool) *SampleOneOf_Field7 { + this := &SampleOneOf_Field7{} + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field8(r randyOne, easy bool) *SampleOneOf_Field8 { + this := &SampleOneOf_Field8{} + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field9(r randyOne, easy bool) *SampleOneOf_Field9 { + this := &SampleOneOf_Field9{} + this.Field9 = uint32(r.Uint32()) + return this +} +func NewPopulatedSampleOneOf_Field10(r randyOne, easy bool) *SampleOneOf_Field10 { + this := &SampleOneOf_Field10{} + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field11(r randyOne, easy bool) *SampleOneOf_Field11 { + this := &SampleOneOf_Field11{} + this.Field11 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedSampleOneOf_Field12(r randyOne, easy bool) *SampleOneOf_Field12 { + this := &SampleOneOf_Field12{} + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field13(r randyOne, easy bool) *SampleOneOf_Field13 { + this := &SampleOneOf_Field13{} + this.Field13 = bool(bool(r.Intn(2) == 0)) + return this +} +func NewPopulatedSampleOneOf_Field14(r randyOne, easy bool) *SampleOneOf_Field14 { + this := &SampleOneOf_Field14{} + this.Field14 = randStringOne(r) + return this +} +func NewPopulatedSampleOneOf_Field15(r randyOne, easy bool) *SampleOneOf_Field15 { + this := &SampleOneOf_Field15{} + v1 := r.Intn(100) + this.Field15 = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedSampleOneOf_SubMessage(r randyOne, easy bool) *SampleOneOf_SubMessage { + this := &SampleOneOf_SubMessage{} + this.SubMessage = NewPopulatedSubby(r, easy) + return this +} + +type randyOne interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneOne(r randyOne) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringOne(r randyOne) string { + v2 := r.Intn(100) + tmps := make([]rune, v2) + for i := 0; i < v2; i++ { + tmps[i] = randUTF8RuneOne(r) + } + return string(tmps) +} +func randUnrecognizedOne(r randyOne, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldOne(data, r, fieldNumber, wire) + } + return data +} +func randFieldOne(data []byte, r randyOne, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateOne(data, uint64(key)) + v3 := r.Int63() + if r.Intn(2) == 0 { + v3 *= -1 + } + data = encodeVarintPopulateOne(data, uint64(v3)) + case 1: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateOne(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateOne(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateOne(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Subby) Size() (n int) { + var l int + _ = l + l = len(m.Sub) + if l > 0 { + n += 1 + l + sovOne(uint64(l)) + } + return n +} + +func (m *SampleOneOf) Size() (n int) { + var l int + _ = l + if m.TestOneof != nil { + n += m.TestOneof.Size() + } + return n +} + +func (m *SampleOneOf_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *SampleOneOf_Field4) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field4)) + return n +} +func (m *SampleOneOf_Field5) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field5)) + return n +} +func (m *SampleOneOf_Field6) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field6)) + return n +} +func (m *SampleOneOf_Field7) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field7)) + return n +} +func (m *SampleOneOf_Field8) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field8)) + return n +} +func (m *SampleOneOf_Field9) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field10) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field11) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field12) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field13) Size() (n int) { + var l int + _ = l + n += 2 + return n +} +func (m *SampleOneOf_Field14) Size() (n int) { + var l int + _ = l + l = len(m.Field14) + n += 1 + l + sovOne(uint64(l)) + return n +} +func (m *SampleOneOf_Field15) Size() (n int) { + var l int + _ = l + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovOne(uint64(l)) + } + return n +} +func (m *SampleOneOf_SubMessage) Size() (n int) { + var l int + _ = l + if m.SubMessage != nil { + l = m.SubMessage.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} + +func sovOne(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozOne(x uint64) (n int) { + return sovOne(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Subby) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Subby{`, + `Sub:` + fmt.Sprintf("%v", this.Sub) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf{`, + `TestOneof:` + fmt.Sprintf("%v", this.TestOneof) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field4) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field4{`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field5) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field5{`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field6) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field6{`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field7) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field7{`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field8) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field8{`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field9) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field9{`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field10) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field10{`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field11) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field11{`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field12) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field12{`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field13) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field13{`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field14) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field14{`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field15) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field15{`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_SubMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_SubMessage{`, + `SubMessage:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func valueToStringOne(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Subby) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Subby: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Subby: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sub", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sub = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOne(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOne + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SampleOneOf) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SampleOneOf: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SampleOneOf: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.TestOneof = &SampleOneOf_Field1{float64(math.Float64frombits(v))} + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.TestOneof = &SampleOneOf_Field2{float32(math.Float32frombits(v))} + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &SampleOneOf_Field3{v} + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &SampleOneOf_Field4{v} + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &SampleOneOf_Field5{v} + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &SampleOneOf_Field6{v} + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.TestOneof = &SampleOneOf_Field7{v} + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.TestOneof = &SampleOneOf_Field8{int64(v)} + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.TestOneof = &SampleOneOf_Field9{v} + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.TestOneof = &SampleOneOf_Field10{v} + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.TestOneof = &SampleOneOf_Field11{v} + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.TestOneof = &SampleOneOf_Field12{v} + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.TestOneof = &SampleOneOf_Field13{b} + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TestOneof = &SampleOneOf_Field14{string(data[iNdEx:postIndex])} + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := make([]byte, postIndex-iNdEx) + copy(v, data[iNdEx:postIndex]) + m.TestOneof = &SampleOneOf_Field15{v} + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &Subby{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.TestOneof = &SampleOneOf_SubMessage{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOne(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOne + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipOne(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOne + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOne + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOne + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthOne + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOne + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipOne(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthOne = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowOne = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/both/one.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/both/one.proto new file mode 100644 index 0000000000000000000000000000000000000000..5c91b6c72cb6b9bf74f4791ddbc080aa707a2d06 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/both/one.proto @@ -0,0 +1,80 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 one; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Subby { + string sub = 1; +} + +message SampleOneOf { + oneof test_oneof { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + int64 Field4 = 4; + uint32 Field5 = 5; + uint64 Field6 = 6; + sint32 Field7 = 7; + sint64 Field8 = 8; + fixed32 Field9 = 9; + sfixed32 Field10 = 10; + fixed64 Field11 = 11; + sfixed64 Field12 = 12; + bool Field13 = 13; + string Field14 = 14; + bytes Field15 = 15; + Subby sub_message = 16; + } +} + + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/both/onepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/both/onepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..3698cb8d6f9f10bb4c22714ab3b2cf7d78c030c3 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/both/onepb_test.go @@ -0,0 +1,390 @@ +// Code generated by protoc-gen-gogo. +// source: combos/both/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/both/one.proto + +It has these top-level messages: + Subby + SampleOneOf +*/ +package one + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestSubbyProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSubbyMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSampleOneOfMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSampleOneOfJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSubbyProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOneDescription(t *testing.T) { + OneDescription() +} +func TestSubbyVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSampleOneOfVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSubbyGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSampleOneOfGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSubbySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSampleOneOfSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSubbyStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestSampleOneOfStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/marshaler/one.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/marshaler/one.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..81f54ee0707bfa0aa87b86c147a8470d6a6b7014 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/marshaler/one.pb.go @@ -0,0 +1,3928 @@ +// Code generated by protoc-gen-gogo. +// source: combos/marshaler/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/marshaler/one.proto + +It has these top-level messages: + Subby + SampleOneOf +*/ +package one + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Subby struct { + Sub string `protobuf:"bytes,1,opt,name=sub,proto3" json:"sub,omitempty"` +} + +func (m *Subby) Reset() { *m = Subby{} } +func (*Subby) ProtoMessage() {} + +type SampleOneOf struct { + // Types that are valid to be assigned to TestOneof: + // *SampleOneOf_Field1 + // *SampleOneOf_Field2 + // *SampleOneOf_Field3 + // *SampleOneOf_Field4 + // *SampleOneOf_Field5 + // *SampleOneOf_Field6 + // *SampleOneOf_Field7 + // *SampleOneOf_Field8 + // *SampleOneOf_Field9 + // *SampleOneOf_Field10 + // *SampleOneOf_Field11 + // *SampleOneOf_Field12 + // *SampleOneOf_Field13 + // *SampleOneOf_Field14 + // *SampleOneOf_Field15 + // *SampleOneOf_SubMessage + TestOneof isSampleOneOf_TestOneof `protobuf_oneof:"test_oneof"` +} + +func (m *SampleOneOf) Reset() { *m = SampleOneOf{} } +func (*SampleOneOf) ProtoMessage() {} + +type isSampleOneOf_TestOneof interface { + isSampleOneOf_TestOneof() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} + +type SampleOneOf_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,proto3,oneof"` +} +type SampleOneOf_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,proto3,oneof"` +} +type SampleOneOf_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,proto3,oneof"` +} +type SampleOneOf_Field4 struct { + Field4 int64 `protobuf:"varint,4,opt,name=Field4,proto3,oneof"` +} +type SampleOneOf_Field5 struct { + Field5 uint32 `protobuf:"varint,5,opt,name=Field5,proto3,oneof"` +} +type SampleOneOf_Field6 struct { + Field6 uint64 `protobuf:"varint,6,opt,name=Field6,proto3,oneof"` +} +type SampleOneOf_Field7 struct { + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7,proto3,oneof"` +} +type SampleOneOf_Field8 struct { + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8,proto3,oneof"` +} +type SampleOneOf_Field9 struct { + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9,proto3,oneof"` +} +type SampleOneOf_Field10 struct { + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10,proto3,oneof"` +} +type SampleOneOf_Field11 struct { + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11,proto3,oneof"` +} +type SampleOneOf_Field12 struct { + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12,proto3,oneof"` +} +type SampleOneOf_Field13 struct { + Field13 bool `protobuf:"varint,13,opt,name=Field13,proto3,oneof"` +} +type SampleOneOf_Field14 struct { + Field14 string `protobuf:"bytes,14,opt,name=Field14,proto3,oneof"` +} +type SampleOneOf_Field15 struct { + Field15 []byte `protobuf:"bytes,15,opt,name=Field15,proto3,oneof"` +} +type SampleOneOf_SubMessage struct { + SubMessage *Subby `protobuf:"bytes,16,opt,name=sub_message,oneof"` +} + +func (*SampleOneOf_Field1) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field2) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field3) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field4) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field5) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field6) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field7) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field8) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field9) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field10) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field11) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field12) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field13) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field14) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field15) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_SubMessage) isSampleOneOf_TestOneof() {} + +func (m *SampleOneOf) GetTestOneof() isSampleOneOf_TestOneof { + if m != nil { + return m.TestOneof + } + return nil +} + +func (m *SampleOneOf) GetField1() float64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *SampleOneOf) GetField2() float32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *SampleOneOf) GetField3() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *SampleOneOf) GetField4() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field4); ok { + return x.Field4 + } + return 0 +} + +func (m *SampleOneOf) GetField5() uint32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field5); ok { + return x.Field5 + } + return 0 +} + +func (m *SampleOneOf) GetField6() uint64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field6); ok { + return x.Field6 + } + return 0 +} + +func (m *SampleOneOf) GetField7() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field7); ok { + return x.Field7 + } + return 0 +} + +func (m *SampleOneOf) GetField8() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field8); ok { + return x.Field8 + } + return 0 +} + +func (m *SampleOneOf) GetField9() uint32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field9); ok { + return x.Field9 + } + return 0 +} + +func (m *SampleOneOf) GetField10() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field10); ok { + return x.Field10 + } + return 0 +} + +func (m *SampleOneOf) GetField11() uint64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field11); ok { + return x.Field11 + } + return 0 +} + +func (m *SampleOneOf) GetField12() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field12); ok { + return x.Field12 + } + return 0 +} + +func (m *SampleOneOf) GetField13() bool { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field13); ok { + return x.Field13 + } + return false +} + +func (m *SampleOneOf) GetField14() string { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field14); ok { + return x.Field14 + } + return "" +} + +func (m *SampleOneOf) GetField15() []byte { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field15); ok { + return x.Field15 + } + return nil +} + +func (m *SampleOneOf) GetSubMessage() *Subby { + if x, ok := m.GetTestOneof().(*SampleOneOf_SubMessage); ok { + return x.SubMessage + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*SampleOneOf) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _SampleOneOf_OneofMarshaler, _SampleOneOf_OneofUnmarshaler, []interface{}{ + (*SampleOneOf_Field1)(nil), + (*SampleOneOf_Field2)(nil), + (*SampleOneOf_Field3)(nil), + (*SampleOneOf_Field4)(nil), + (*SampleOneOf_Field5)(nil), + (*SampleOneOf_Field6)(nil), + (*SampleOneOf_Field7)(nil), + (*SampleOneOf_Field8)(nil), + (*SampleOneOf_Field9)(nil), + (*SampleOneOf_Field10)(nil), + (*SampleOneOf_Field11)(nil), + (*SampleOneOf_Field12)(nil), + (*SampleOneOf_Field13)(nil), + (*SampleOneOf_Field14)(nil), + (*SampleOneOf_Field15)(nil), + (*SampleOneOf_SubMessage)(nil), + } +} + +func _SampleOneOf_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*SampleOneOf) + // test_oneof + switch x := m.TestOneof.(type) { + case *SampleOneOf_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *SampleOneOf_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *SampleOneOf_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case *SampleOneOf_Field4: + _ = b.EncodeVarint(4<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field4)) + case *SampleOneOf_Field5: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field5)) + case *SampleOneOf_Field6: + _ = b.EncodeVarint(6<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field6)) + case *SampleOneOf_Field7: + _ = b.EncodeVarint(7<<3 | proto.WireVarint) + _ = b.EncodeZigzag32(uint64(x.Field7)) + case *SampleOneOf_Field8: + _ = b.EncodeVarint(8<<3 | proto.WireVarint) + _ = b.EncodeZigzag64(uint64(x.Field8)) + case *SampleOneOf_Field9: + _ = b.EncodeVarint(9<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field9)) + case *SampleOneOf_Field10: + _ = b.EncodeVarint(10<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field10)) + case *SampleOneOf_Field11: + _ = b.EncodeVarint(11<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field11)) + case *SampleOneOf_Field12: + _ = b.EncodeVarint(12<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field12)) + case *SampleOneOf_Field13: + t := uint64(0) + if x.Field13 { + t = 1 + } + _ = b.EncodeVarint(13<<3 | proto.WireVarint) + _ = b.EncodeVarint(t) + case *SampleOneOf_Field14: + _ = b.EncodeVarint(14<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field14) + case *SampleOneOf_Field15: + _ = b.EncodeVarint(15<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field15) + case *SampleOneOf_SubMessage: + _ = b.EncodeVarint(16<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("SampleOneOf.TestOneof has unexpected type %T", x) + } + return nil +} + +func _SampleOneOf_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*SampleOneOf) + switch tag { + case 1: // test_oneof.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field1{math.Float64frombits(x)} + return true, err + case 2: // test_oneof.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // test_oneof.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field3{int32(x)} + return true, err + case 4: // test_oneof.Field4 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field4{int64(x)} + return true, err + case 5: // test_oneof.Field5 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field5{uint32(x)} + return true, err + case 6: // test_oneof.Field6 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field6{x} + return true, err + case 7: // test_oneof.Field7 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag32() + m.TestOneof = &SampleOneOf_Field7{int32(x)} + return true, err + case 8: // test_oneof.Field8 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag64() + m.TestOneof = &SampleOneOf_Field8{int64(x)} + return true, err + case 9: // test_oneof.Field9 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field9{uint32(x)} + return true, err + case 10: // test_oneof.Field10 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field10{int32(x)} + return true, err + case 11: // test_oneof.Field11 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field11{x} + return true, err + case 12: // test_oneof.Field12 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field12{int64(x)} + return true, err + case 13: // test_oneof.Field13 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field13{x != 0} + return true, err + case 14: // test_oneof.Field14 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.TestOneof = &SampleOneOf_Field14{x} + return true, err + case 15: // test_oneof.Field15 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.TestOneof = &SampleOneOf_Field15{x} + return true, err + case 16: // test_oneof.sub_message + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.TestOneof = &SampleOneOf_SubMessage{msg} + return true, err + default: + return false, nil + } +} + +func (this *Subby) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *SampleOneOf) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func OneDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/marshaler/one.proto"), + Package: func(v string) *string { return &v }("one"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Subby"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("sub"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("SampleOneOf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("sub_message"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(0), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("test_oneof")}}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + Syntax: func(v string) *string { return &v }("proto3"), + }}, + } +} +func (this *Subby) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Subby) + if !ok { + return fmt.Errorf("that is not of type *Subby") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Subby but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Subbybut is not nil && this == nil") + } + if this.Sub != that1.Sub { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) + } + return nil +} +func (this *Subby) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Subby) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Sub != that1.Sub { + return false + } + return true +} +func (this *SampleOneOf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOfbut is not nil && this == nil") + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return fmt.Errorf("this.TestOneof != nil && that1.TestOneof == nil") + } + } else if this.TestOneof == nil { + return fmt.Errorf("this.TestOneof == nil && that1.TestOneof != nil") + } else if err := this.TestOneof.VerboseEqual(that1.TestOneof); err != nil { + return err + } + return nil +} +func (this *SampleOneOf_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field1) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *SampleOneOf_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field2) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *SampleOneOf_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field3) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *SampleOneOf_Field4) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field4) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field4") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field4 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field4but is not nil && this == nil") + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + return nil +} +func (this *SampleOneOf_Field5) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field5) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field5") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field5 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field5but is not nil && this == nil") + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + return nil +} +func (this *SampleOneOf_Field6) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field6) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field6") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field6 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field6but is not nil && this == nil") + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + return nil +} +func (this *SampleOneOf_Field7) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field7) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field7") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field7 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field7but is not nil && this == nil") + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + return nil +} +func (this *SampleOneOf_Field8) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field8) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field8") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field8 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field8but is not nil && this == nil") + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + return nil +} +func (this *SampleOneOf_Field9) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field9) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field9") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field9 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field9but is not nil && this == nil") + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + return nil +} +func (this *SampleOneOf_Field10) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field10) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field10") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field10 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field10but is not nil && this == nil") + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + return nil +} +func (this *SampleOneOf_Field11) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field11) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field11") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field11 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field11but is not nil && this == nil") + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + return nil +} +func (this *SampleOneOf_Field12) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field12) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field12") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field12 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field12but is not nil && this == nil") + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + return nil +} +func (this *SampleOneOf_Field13) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field13) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field13") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field13 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field13but is not nil && this == nil") + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + return nil +} +func (this *SampleOneOf_Field14) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field14) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field14") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field14 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field14but is not nil && this == nil") + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + return nil +} +func (this *SampleOneOf_Field15) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field15) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field15") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field15 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field15but is not nil && this == nil") + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + return nil +} +func (this *SampleOneOf_SubMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_SubMessage) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_SubMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_SubMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_SubMessagebut is not nil && this == nil") + } + if !this.SubMessage.Equal(that1.SubMessage) { + return fmt.Errorf("SubMessage this(%v) Not Equal that(%v)", this.SubMessage, that1.SubMessage) + } + return nil +} +func (this *SampleOneOf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return false + } + } else if this.TestOneof == nil { + return false + } else if !this.TestOneof.Equal(that1.TestOneof) { + return false + } + return true +} +func (this *SampleOneOf_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *SampleOneOf_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *SampleOneOf_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *SampleOneOf_Field4) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field4) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field4 != that1.Field4 { + return false + } + return true +} +func (this *SampleOneOf_Field5) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field5) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field5 != that1.Field5 { + return false + } + return true +} +func (this *SampleOneOf_Field6) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field6) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field6 != that1.Field6 { + return false + } + return true +} +func (this *SampleOneOf_Field7) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field7) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field7 != that1.Field7 { + return false + } + return true +} +func (this *SampleOneOf_Field8) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field8) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field8 != that1.Field8 { + return false + } + return true +} +func (this *SampleOneOf_Field9) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field9) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field9 != that1.Field9 { + return false + } + return true +} +func (this *SampleOneOf_Field10) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field10) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field10 != that1.Field10 { + return false + } + return true +} +func (this *SampleOneOf_Field11) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field11) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field11 != that1.Field11 { + return false + } + return true +} +func (this *SampleOneOf_Field12) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field12) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field12 != that1.Field12 { + return false + } + return true +} +func (this *SampleOneOf_Field13) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field13) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field13 != that1.Field13 { + return false + } + return true +} +func (this *SampleOneOf_Field14) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field14) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field14 != that1.Field14 { + return false + } + return true +} +func (this *SampleOneOf_Field15) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field15) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + return true +} +func (this *SampleOneOf_SubMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_SubMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage.Equal(that1.SubMessage) { + return false + } + return true +} +func (this *Subby) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&one.Subby{") + s = append(s, "Sub: "+fmt.Sprintf("%#v", this.Sub)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SampleOneOf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 20) + s = append(s, "&one.SampleOneOf{") + if this.TestOneof != nil { + s = append(s, "TestOneof: "+fmt.Sprintf("%#v", this.TestOneof)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SampleOneOf_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field4) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field4{` + + `Field4:` + fmt.Sprintf("%#v", this.Field4) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field5) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field5{` + + `Field5:` + fmt.Sprintf("%#v", this.Field5) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field6) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field6{` + + `Field6:` + fmt.Sprintf("%#v", this.Field6) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field7) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field7{` + + `Field7:` + fmt.Sprintf("%#v", this.Field7) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field8) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field8{` + + `Field8:` + fmt.Sprintf("%#v", this.Field8) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field9) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field9{` + + `Field9:` + fmt.Sprintf("%#v", this.Field9) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field10) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field10{` + + `Field10:` + fmt.Sprintf("%#v", this.Field10) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field11) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field11{` + + `Field11:` + fmt.Sprintf("%#v", this.Field11) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field12) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field12{` + + `Field12:` + fmt.Sprintf("%#v", this.Field12) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field13) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field13{` + + `Field13:` + fmt.Sprintf("%#v", this.Field13) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field14) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field14{` + + `Field14:` + fmt.Sprintf("%#v", this.Field14) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field15) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field15{` + + `Field15:` + fmt.Sprintf("%#v", this.Field15) + `}`}, ", ") + return s +} +func (this *SampleOneOf_SubMessage) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_SubMessage{` + + `SubMessage:` + fmt.Sprintf("%#v", this.SubMessage) + `}`}, ", ") + return s +} +func valueToGoStringOne(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringOne(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *Subby) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Subby) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Sub) > 0 { + data[i] = 0xa + i++ + i = encodeVarintOne(data, i, uint64(len(m.Sub))) + i += copy(data[i:], m.Sub) + } + return i, nil +} + +func (m *SampleOneOf) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *SampleOneOf) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.TestOneof != nil { + nn1, err := m.TestOneof.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn1 + } + return i, nil +} + +func (m *SampleOneOf_Field1) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x9 + i++ + i = encodeFixed64One(data, i, uint64(math.Float64bits(m.Field1))) + return i, nil +} +func (m *SampleOneOf_Field2) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x15 + i++ + i = encodeFixed32One(data, i, uint32(math.Float32bits(m.Field2))) + return i, nil +} +func (m *SampleOneOf_Field3) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x18 + i++ + i = encodeVarintOne(data, i, uint64(m.Field3)) + return i, nil +} +func (m *SampleOneOf_Field4) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x20 + i++ + i = encodeVarintOne(data, i, uint64(m.Field4)) + return i, nil +} +func (m *SampleOneOf_Field5) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x28 + i++ + i = encodeVarintOne(data, i, uint64(m.Field5)) + return i, nil +} +func (m *SampleOneOf_Field6) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x30 + i++ + i = encodeVarintOne(data, i, uint64(m.Field6)) + return i, nil +} +func (m *SampleOneOf_Field7) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x38 + i++ + i = encodeVarintOne(data, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31)))) + return i, nil +} +func (m *SampleOneOf_Field8) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x40 + i++ + i = encodeVarintOne(data, i, uint64((uint64(m.Field8)<<1)^uint64((m.Field8>>63)))) + return i, nil +} +func (m *SampleOneOf_Field9) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x4d + i++ + i = encodeFixed32One(data, i, uint32(m.Field9)) + return i, nil +} +func (m *SampleOneOf_Field10) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x55 + i++ + i = encodeFixed32One(data, i, uint32(m.Field10)) + return i, nil +} +func (m *SampleOneOf_Field11) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x59 + i++ + i = encodeFixed64One(data, i, uint64(m.Field11)) + return i, nil +} +func (m *SampleOneOf_Field12) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x61 + i++ + i = encodeFixed64One(data, i, uint64(m.Field12)) + return i, nil +} +func (m *SampleOneOf_Field13) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x68 + i++ + if m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + return i, nil +} +func (m *SampleOneOf_Field14) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x72 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field14))) + i += copy(data[i:], m.Field14) + return i, nil +} +func (m *SampleOneOf_Field15) MarshalTo(data []byte) (int, error) { + i := 0 + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + return i, nil +} +func (m *SampleOneOf_SubMessage) MarshalTo(data []byte) (int, error) { + i := 0 + if m.SubMessage != nil { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + i = encodeVarintOne(data, i, uint64(m.SubMessage.Size())) + n2, err := m.SubMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + } + return i, nil +} +func encodeFixed64One(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32One(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintOne(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedSubby(r randyOne, easy bool) *Subby { + this := &Subby{} + this.Sub = randStringOne(r) + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedSampleOneOf(r randyOne, easy bool) *SampleOneOf { + this := &SampleOneOf{} + oneofNumber_TestOneof := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}[r.Intn(16)] + switch oneofNumber_TestOneof { + case 1: + this.TestOneof = NewPopulatedSampleOneOf_Field1(r, easy) + case 2: + this.TestOneof = NewPopulatedSampleOneOf_Field2(r, easy) + case 3: + this.TestOneof = NewPopulatedSampleOneOf_Field3(r, easy) + case 4: + this.TestOneof = NewPopulatedSampleOneOf_Field4(r, easy) + case 5: + this.TestOneof = NewPopulatedSampleOneOf_Field5(r, easy) + case 6: + this.TestOneof = NewPopulatedSampleOneOf_Field6(r, easy) + case 7: + this.TestOneof = NewPopulatedSampleOneOf_Field7(r, easy) + case 8: + this.TestOneof = NewPopulatedSampleOneOf_Field8(r, easy) + case 9: + this.TestOneof = NewPopulatedSampleOneOf_Field9(r, easy) + case 10: + this.TestOneof = NewPopulatedSampleOneOf_Field10(r, easy) + case 11: + this.TestOneof = NewPopulatedSampleOneOf_Field11(r, easy) + case 12: + this.TestOneof = NewPopulatedSampleOneOf_Field12(r, easy) + case 13: + this.TestOneof = NewPopulatedSampleOneOf_Field13(r, easy) + case 14: + this.TestOneof = NewPopulatedSampleOneOf_Field14(r, easy) + case 15: + this.TestOneof = NewPopulatedSampleOneOf_Field15(r, easy) + case 16: + this.TestOneof = NewPopulatedSampleOneOf_SubMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedSampleOneOf_Field1(r randyOne, easy bool) *SampleOneOf_Field1 { + this := &SampleOneOf_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field2(r randyOne, easy bool) *SampleOneOf_Field2 { + this := &SampleOneOf_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field3(r randyOne, easy bool) *SampleOneOf_Field3 { + this := &SampleOneOf_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field4(r randyOne, easy bool) *SampleOneOf_Field4 { + this := &SampleOneOf_Field4{} + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field5(r randyOne, easy bool) *SampleOneOf_Field5 { + this := &SampleOneOf_Field5{} + this.Field5 = uint32(r.Uint32()) + return this +} +func NewPopulatedSampleOneOf_Field6(r randyOne, easy bool) *SampleOneOf_Field6 { + this := &SampleOneOf_Field6{} + this.Field6 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedSampleOneOf_Field7(r randyOne, easy bool) *SampleOneOf_Field7 { + this := &SampleOneOf_Field7{} + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field8(r randyOne, easy bool) *SampleOneOf_Field8 { + this := &SampleOneOf_Field8{} + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field9(r randyOne, easy bool) *SampleOneOf_Field9 { + this := &SampleOneOf_Field9{} + this.Field9 = uint32(r.Uint32()) + return this +} +func NewPopulatedSampleOneOf_Field10(r randyOne, easy bool) *SampleOneOf_Field10 { + this := &SampleOneOf_Field10{} + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field11(r randyOne, easy bool) *SampleOneOf_Field11 { + this := &SampleOneOf_Field11{} + this.Field11 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedSampleOneOf_Field12(r randyOne, easy bool) *SampleOneOf_Field12 { + this := &SampleOneOf_Field12{} + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field13(r randyOne, easy bool) *SampleOneOf_Field13 { + this := &SampleOneOf_Field13{} + this.Field13 = bool(bool(r.Intn(2) == 0)) + return this +} +func NewPopulatedSampleOneOf_Field14(r randyOne, easy bool) *SampleOneOf_Field14 { + this := &SampleOneOf_Field14{} + this.Field14 = randStringOne(r) + return this +} +func NewPopulatedSampleOneOf_Field15(r randyOne, easy bool) *SampleOneOf_Field15 { + this := &SampleOneOf_Field15{} + v1 := r.Intn(100) + this.Field15 = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedSampleOneOf_SubMessage(r randyOne, easy bool) *SampleOneOf_SubMessage { + this := &SampleOneOf_SubMessage{} + this.SubMessage = NewPopulatedSubby(r, easy) + return this +} + +type randyOne interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneOne(r randyOne) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringOne(r randyOne) string { + v2 := r.Intn(100) + tmps := make([]rune, v2) + for i := 0; i < v2; i++ { + tmps[i] = randUTF8RuneOne(r) + } + return string(tmps) +} +func randUnrecognizedOne(r randyOne, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldOne(data, r, fieldNumber, wire) + } + return data +} +func randFieldOne(data []byte, r randyOne, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateOne(data, uint64(key)) + v3 := r.Int63() + if r.Intn(2) == 0 { + v3 *= -1 + } + data = encodeVarintPopulateOne(data, uint64(v3)) + case 1: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateOne(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateOne(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateOne(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Subby) Size() (n int) { + var l int + _ = l + l = len(m.Sub) + if l > 0 { + n += 1 + l + sovOne(uint64(l)) + } + return n +} + +func (m *SampleOneOf) Size() (n int) { + var l int + _ = l + if m.TestOneof != nil { + n += m.TestOneof.Size() + } + return n +} + +func (m *SampleOneOf_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *SampleOneOf_Field4) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field4)) + return n +} +func (m *SampleOneOf_Field5) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field5)) + return n +} +func (m *SampleOneOf_Field6) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field6)) + return n +} +func (m *SampleOneOf_Field7) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field7)) + return n +} +func (m *SampleOneOf_Field8) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field8)) + return n +} +func (m *SampleOneOf_Field9) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field10) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field11) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field12) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field13) Size() (n int) { + var l int + _ = l + n += 2 + return n +} +func (m *SampleOneOf_Field14) Size() (n int) { + var l int + _ = l + l = len(m.Field14) + n += 1 + l + sovOne(uint64(l)) + return n +} +func (m *SampleOneOf_Field15) Size() (n int) { + var l int + _ = l + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovOne(uint64(l)) + } + return n +} +func (m *SampleOneOf_SubMessage) Size() (n int) { + var l int + _ = l + if m.SubMessage != nil { + l = m.SubMessage.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} + +func sovOne(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozOne(x uint64) (n int) { + return sovOne(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Subby) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Subby{`, + `Sub:` + fmt.Sprintf("%v", this.Sub) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf{`, + `TestOneof:` + fmt.Sprintf("%v", this.TestOneof) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field4) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field4{`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field5) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field5{`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field6) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field6{`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field7) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field7{`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field8) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field8{`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field9) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field9{`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field10) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field10{`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field11) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field11{`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field12) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field12{`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field13) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field13{`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field14) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field14{`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field15) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field15{`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_SubMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_SubMessage{`, + `SubMessage:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func valueToStringOne(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/marshaler/one.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/marshaler/one.proto new file mode 100644 index 0000000000000000000000000000000000000000..e8f562ebdfa457fec08f2add957dc9478e634825 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/marshaler/one.proto @@ -0,0 +1,80 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 one; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Subby { + string sub = 1; +} + +message SampleOneOf { + oneof test_oneof { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + int64 Field4 = 4; + uint32 Field5 = 5; + uint64 Field6 = 6; + sint32 Field7 = 7; + sint64 Field8 = 8; + fixed32 Field9 = 9; + sfixed32 Field10 = 10; + fixed64 Field11 = 11; + sfixed64 Field12 = 12; + bool Field13 = 13; + string Field14 = 14; + bytes Field15 = 15; + Subby sub_message = 16; + } +} + + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/marshaler/onepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/marshaler/onepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..909f4597e8bcaba64010353e41e84ab74cedc8c8 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/marshaler/onepb_test.go @@ -0,0 +1,390 @@ +// Code generated by protoc-gen-gogo. +// source: combos/marshaler/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/marshaler/one.proto + +It has these top-level messages: + Subby + SampleOneOf +*/ +package one + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestSubbyProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSubbyMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSampleOneOfMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSampleOneOfJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSubbyProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOneDescription(t *testing.T) { + OneDescription() +} +func TestSubbyVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSampleOneOfVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSubbyGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSampleOneOfGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSubbySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSampleOneOfSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSubbyStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestSampleOneOfStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/neither/one.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/neither/one.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..ca07ddf2aa734efec8a81ccb8fc419851dff85d9 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/neither/one.pb.go @@ -0,0 +1,3721 @@ +// Code generated by protoc-gen-gogo. +// source: combos/neither/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/neither/one.proto + +It has these top-level messages: + Subby + SampleOneOf +*/ +package one + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Subby struct { + Sub string `protobuf:"bytes,1,opt,name=sub,proto3" json:"sub,omitempty"` +} + +func (m *Subby) Reset() { *m = Subby{} } +func (*Subby) ProtoMessage() {} + +type SampleOneOf struct { + // Types that are valid to be assigned to TestOneof: + // *SampleOneOf_Field1 + // *SampleOneOf_Field2 + // *SampleOneOf_Field3 + // *SampleOneOf_Field4 + // *SampleOneOf_Field5 + // *SampleOneOf_Field6 + // *SampleOneOf_Field7 + // *SampleOneOf_Field8 + // *SampleOneOf_Field9 + // *SampleOneOf_Field10 + // *SampleOneOf_Field11 + // *SampleOneOf_Field12 + // *SampleOneOf_Field13 + // *SampleOneOf_Field14 + // *SampleOneOf_Field15 + // *SampleOneOf_SubMessage + TestOneof isSampleOneOf_TestOneof `protobuf_oneof:"test_oneof"` +} + +func (m *SampleOneOf) Reset() { *m = SampleOneOf{} } +func (*SampleOneOf) ProtoMessage() {} + +type isSampleOneOf_TestOneof interface { + isSampleOneOf_TestOneof() + Equal(interface{}) bool + VerboseEqual(interface{}) error + Size() int +} + +type SampleOneOf_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,proto3,oneof"` +} +type SampleOneOf_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,proto3,oneof"` +} +type SampleOneOf_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,proto3,oneof"` +} +type SampleOneOf_Field4 struct { + Field4 int64 `protobuf:"varint,4,opt,name=Field4,proto3,oneof"` +} +type SampleOneOf_Field5 struct { + Field5 uint32 `protobuf:"varint,5,opt,name=Field5,proto3,oneof"` +} +type SampleOneOf_Field6 struct { + Field6 uint64 `protobuf:"varint,6,opt,name=Field6,proto3,oneof"` +} +type SampleOneOf_Field7 struct { + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7,proto3,oneof"` +} +type SampleOneOf_Field8 struct { + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8,proto3,oneof"` +} +type SampleOneOf_Field9 struct { + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9,proto3,oneof"` +} +type SampleOneOf_Field10 struct { + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10,proto3,oneof"` +} +type SampleOneOf_Field11 struct { + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11,proto3,oneof"` +} +type SampleOneOf_Field12 struct { + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12,proto3,oneof"` +} +type SampleOneOf_Field13 struct { + Field13 bool `protobuf:"varint,13,opt,name=Field13,proto3,oneof"` +} +type SampleOneOf_Field14 struct { + Field14 string `protobuf:"bytes,14,opt,name=Field14,proto3,oneof"` +} +type SampleOneOf_Field15 struct { + Field15 []byte `protobuf:"bytes,15,opt,name=Field15,proto3,oneof"` +} +type SampleOneOf_SubMessage struct { + SubMessage *Subby `protobuf:"bytes,16,opt,name=sub_message,oneof"` +} + +func (*SampleOneOf_Field1) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field2) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field3) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field4) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field5) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field6) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field7) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field8) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field9) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field10) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field11) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field12) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field13) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field14) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field15) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_SubMessage) isSampleOneOf_TestOneof() {} + +func (m *SampleOneOf) GetTestOneof() isSampleOneOf_TestOneof { + if m != nil { + return m.TestOneof + } + return nil +} + +func (m *SampleOneOf) GetField1() float64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *SampleOneOf) GetField2() float32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *SampleOneOf) GetField3() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *SampleOneOf) GetField4() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field4); ok { + return x.Field4 + } + return 0 +} + +func (m *SampleOneOf) GetField5() uint32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field5); ok { + return x.Field5 + } + return 0 +} + +func (m *SampleOneOf) GetField6() uint64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field6); ok { + return x.Field6 + } + return 0 +} + +func (m *SampleOneOf) GetField7() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field7); ok { + return x.Field7 + } + return 0 +} + +func (m *SampleOneOf) GetField8() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field8); ok { + return x.Field8 + } + return 0 +} + +func (m *SampleOneOf) GetField9() uint32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field9); ok { + return x.Field9 + } + return 0 +} + +func (m *SampleOneOf) GetField10() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field10); ok { + return x.Field10 + } + return 0 +} + +func (m *SampleOneOf) GetField11() uint64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field11); ok { + return x.Field11 + } + return 0 +} + +func (m *SampleOneOf) GetField12() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field12); ok { + return x.Field12 + } + return 0 +} + +func (m *SampleOneOf) GetField13() bool { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field13); ok { + return x.Field13 + } + return false +} + +func (m *SampleOneOf) GetField14() string { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field14); ok { + return x.Field14 + } + return "" +} + +func (m *SampleOneOf) GetField15() []byte { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field15); ok { + return x.Field15 + } + return nil +} + +func (m *SampleOneOf) GetSubMessage() *Subby { + if x, ok := m.GetTestOneof().(*SampleOneOf_SubMessage); ok { + return x.SubMessage + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*SampleOneOf) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _SampleOneOf_OneofMarshaler, _SampleOneOf_OneofUnmarshaler, []interface{}{ + (*SampleOneOf_Field1)(nil), + (*SampleOneOf_Field2)(nil), + (*SampleOneOf_Field3)(nil), + (*SampleOneOf_Field4)(nil), + (*SampleOneOf_Field5)(nil), + (*SampleOneOf_Field6)(nil), + (*SampleOneOf_Field7)(nil), + (*SampleOneOf_Field8)(nil), + (*SampleOneOf_Field9)(nil), + (*SampleOneOf_Field10)(nil), + (*SampleOneOf_Field11)(nil), + (*SampleOneOf_Field12)(nil), + (*SampleOneOf_Field13)(nil), + (*SampleOneOf_Field14)(nil), + (*SampleOneOf_Field15)(nil), + (*SampleOneOf_SubMessage)(nil), + } +} + +func _SampleOneOf_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*SampleOneOf) + // test_oneof + switch x := m.TestOneof.(type) { + case *SampleOneOf_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *SampleOneOf_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *SampleOneOf_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case *SampleOneOf_Field4: + _ = b.EncodeVarint(4<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field4)) + case *SampleOneOf_Field5: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field5)) + case *SampleOneOf_Field6: + _ = b.EncodeVarint(6<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field6)) + case *SampleOneOf_Field7: + _ = b.EncodeVarint(7<<3 | proto.WireVarint) + _ = b.EncodeZigzag32(uint64(x.Field7)) + case *SampleOneOf_Field8: + _ = b.EncodeVarint(8<<3 | proto.WireVarint) + _ = b.EncodeZigzag64(uint64(x.Field8)) + case *SampleOneOf_Field9: + _ = b.EncodeVarint(9<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field9)) + case *SampleOneOf_Field10: + _ = b.EncodeVarint(10<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field10)) + case *SampleOneOf_Field11: + _ = b.EncodeVarint(11<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field11)) + case *SampleOneOf_Field12: + _ = b.EncodeVarint(12<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field12)) + case *SampleOneOf_Field13: + t := uint64(0) + if x.Field13 { + t = 1 + } + _ = b.EncodeVarint(13<<3 | proto.WireVarint) + _ = b.EncodeVarint(t) + case *SampleOneOf_Field14: + _ = b.EncodeVarint(14<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field14) + case *SampleOneOf_Field15: + _ = b.EncodeVarint(15<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field15) + case *SampleOneOf_SubMessage: + _ = b.EncodeVarint(16<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("SampleOneOf.TestOneof has unexpected type %T", x) + } + return nil +} + +func _SampleOneOf_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*SampleOneOf) + switch tag { + case 1: // test_oneof.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field1{math.Float64frombits(x)} + return true, err + case 2: // test_oneof.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // test_oneof.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field3{int32(x)} + return true, err + case 4: // test_oneof.Field4 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field4{int64(x)} + return true, err + case 5: // test_oneof.Field5 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field5{uint32(x)} + return true, err + case 6: // test_oneof.Field6 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field6{x} + return true, err + case 7: // test_oneof.Field7 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag32() + m.TestOneof = &SampleOneOf_Field7{int32(x)} + return true, err + case 8: // test_oneof.Field8 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag64() + m.TestOneof = &SampleOneOf_Field8{int64(x)} + return true, err + case 9: // test_oneof.Field9 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field9{uint32(x)} + return true, err + case 10: // test_oneof.Field10 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field10{int32(x)} + return true, err + case 11: // test_oneof.Field11 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field11{x} + return true, err + case 12: // test_oneof.Field12 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field12{int64(x)} + return true, err + case 13: // test_oneof.Field13 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field13{x != 0} + return true, err + case 14: // test_oneof.Field14 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.TestOneof = &SampleOneOf_Field14{x} + return true, err + case 15: // test_oneof.Field15 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.TestOneof = &SampleOneOf_Field15{x} + return true, err + case 16: // test_oneof.sub_message + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.TestOneof = &SampleOneOf_SubMessage{msg} + return true, err + default: + return false, nil + } +} + +func (this *Subby) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *SampleOneOf) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func OneDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/neither/one.proto"), + Package: func(v string) *string { return &v }("one"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Subby"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("sub"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("SampleOneOf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("sub_message"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(0), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("test_oneof")}}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + Syntax: func(v string) *string { return &v }("proto3"), + }}, + } +} +func (this *Subby) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Subby) + if !ok { + return fmt.Errorf("that is not of type *Subby") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Subby but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Subbybut is not nil && this == nil") + } + if this.Sub != that1.Sub { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) + } + return nil +} +func (this *Subby) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Subby) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Sub != that1.Sub { + return false + } + return true +} +func (this *SampleOneOf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOfbut is not nil && this == nil") + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return fmt.Errorf("this.TestOneof != nil && that1.TestOneof == nil") + } + } else if this.TestOneof == nil { + return fmt.Errorf("this.TestOneof == nil && that1.TestOneof != nil") + } else if err := this.TestOneof.VerboseEqual(that1.TestOneof); err != nil { + return err + } + return nil +} +func (this *SampleOneOf_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field1) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *SampleOneOf_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field2) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *SampleOneOf_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field3) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *SampleOneOf_Field4) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field4) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field4") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field4 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field4but is not nil && this == nil") + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + return nil +} +func (this *SampleOneOf_Field5) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field5) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field5") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field5 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field5but is not nil && this == nil") + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + return nil +} +func (this *SampleOneOf_Field6) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field6) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field6") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field6 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field6but is not nil && this == nil") + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + return nil +} +func (this *SampleOneOf_Field7) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field7) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field7") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field7 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field7but is not nil && this == nil") + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + return nil +} +func (this *SampleOneOf_Field8) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field8) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field8") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field8 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field8but is not nil && this == nil") + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + return nil +} +func (this *SampleOneOf_Field9) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field9) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field9") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field9 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field9but is not nil && this == nil") + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + return nil +} +func (this *SampleOneOf_Field10) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field10) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field10") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field10 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field10but is not nil && this == nil") + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + return nil +} +func (this *SampleOneOf_Field11) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field11) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field11") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field11 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field11but is not nil && this == nil") + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + return nil +} +func (this *SampleOneOf_Field12) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field12) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field12") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field12 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field12but is not nil && this == nil") + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + return nil +} +func (this *SampleOneOf_Field13) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field13) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field13") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field13 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field13but is not nil && this == nil") + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + return nil +} +func (this *SampleOneOf_Field14) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field14) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field14") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field14 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field14but is not nil && this == nil") + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + return nil +} +func (this *SampleOneOf_Field15) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field15) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field15") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field15 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field15but is not nil && this == nil") + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + return nil +} +func (this *SampleOneOf_SubMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_SubMessage) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_SubMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_SubMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_SubMessagebut is not nil && this == nil") + } + if !this.SubMessage.Equal(that1.SubMessage) { + return fmt.Errorf("SubMessage this(%v) Not Equal that(%v)", this.SubMessage, that1.SubMessage) + } + return nil +} +func (this *SampleOneOf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return false + } + } else if this.TestOneof == nil { + return false + } else if !this.TestOneof.Equal(that1.TestOneof) { + return false + } + return true +} +func (this *SampleOneOf_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *SampleOneOf_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *SampleOneOf_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *SampleOneOf_Field4) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field4) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field4 != that1.Field4 { + return false + } + return true +} +func (this *SampleOneOf_Field5) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field5) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field5 != that1.Field5 { + return false + } + return true +} +func (this *SampleOneOf_Field6) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field6) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field6 != that1.Field6 { + return false + } + return true +} +func (this *SampleOneOf_Field7) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field7) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field7 != that1.Field7 { + return false + } + return true +} +func (this *SampleOneOf_Field8) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field8) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field8 != that1.Field8 { + return false + } + return true +} +func (this *SampleOneOf_Field9) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field9) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field9 != that1.Field9 { + return false + } + return true +} +func (this *SampleOneOf_Field10) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field10) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field10 != that1.Field10 { + return false + } + return true +} +func (this *SampleOneOf_Field11) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field11) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field11 != that1.Field11 { + return false + } + return true +} +func (this *SampleOneOf_Field12) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field12) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field12 != that1.Field12 { + return false + } + return true +} +func (this *SampleOneOf_Field13) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field13) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field13 != that1.Field13 { + return false + } + return true +} +func (this *SampleOneOf_Field14) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field14) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field14 != that1.Field14 { + return false + } + return true +} +func (this *SampleOneOf_Field15) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field15) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + return true +} +func (this *SampleOneOf_SubMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_SubMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage.Equal(that1.SubMessage) { + return false + } + return true +} +func (this *Subby) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&one.Subby{") + s = append(s, "Sub: "+fmt.Sprintf("%#v", this.Sub)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SampleOneOf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 20) + s = append(s, "&one.SampleOneOf{") + if this.TestOneof != nil { + s = append(s, "TestOneof: "+fmt.Sprintf("%#v", this.TestOneof)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SampleOneOf_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field4) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field4{` + + `Field4:` + fmt.Sprintf("%#v", this.Field4) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field5) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field5{` + + `Field5:` + fmt.Sprintf("%#v", this.Field5) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field6) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field6{` + + `Field6:` + fmt.Sprintf("%#v", this.Field6) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field7) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field7{` + + `Field7:` + fmt.Sprintf("%#v", this.Field7) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field8) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field8{` + + `Field8:` + fmt.Sprintf("%#v", this.Field8) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field9) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field9{` + + `Field9:` + fmt.Sprintf("%#v", this.Field9) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field10) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field10{` + + `Field10:` + fmt.Sprintf("%#v", this.Field10) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field11) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field11{` + + `Field11:` + fmt.Sprintf("%#v", this.Field11) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field12) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field12{` + + `Field12:` + fmt.Sprintf("%#v", this.Field12) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field13) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field13{` + + `Field13:` + fmt.Sprintf("%#v", this.Field13) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field14) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field14{` + + `Field14:` + fmt.Sprintf("%#v", this.Field14) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field15) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field15{` + + `Field15:` + fmt.Sprintf("%#v", this.Field15) + `}`}, ", ") + return s +} +func (this *SampleOneOf_SubMessage) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_SubMessage{` + + `SubMessage:` + fmt.Sprintf("%#v", this.SubMessage) + `}`}, ", ") + return s +} +func valueToGoStringOne(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringOne(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedSubby(r randyOne, easy bool) *Subby { + this := &Subby{} + this.Sub = randStringOne(r) + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedSampleOneOf(r randyOne, easy bool) *SampleOneOf { + this := &SampleOneOf{} + oneofNumber_TestOneof := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}[r.Intn(16)] + switch oneofNumber_TestOneof { + case 1: + this.TestOneof = NewPopulatedSampleOneOf_Field1(r, easy) + case 2: + this.TestOneof = NewPopulatedSampleOneOf_Field2(r, easy) + case 3: + this.TestOneof = NewPopulatedSampleOneOf_Field3(r, easy) + case 4: + this.TestOneof = NewPopulatedSampleOneOf_Field4(r, easy) + case 5: + this.TestOneof = NewPopulatedSampleOneOf_Field5(r, easy) + case 6: + this.TestOneof = NewPopulatedSampleOneOf_Field6(r, easy) + case 7: + this.TestOneof = NewPopulatedSampleOneOf_Field7(r, easy) + case 8: + this.TestOneof = NewPopulatedSampleOneOf_Field8(r, easy) + case 9: + this.TestOneof = NewPopulatedSampleOneOf_Field9(r, easy) + case 10: + this.TestOneof = NewPopulatedSampleOneOf_Field10(r, easy) + case 11: + this.TestOneof = NewPopulatedSampleOneOf_Field11(r, easy) + case 12: + this.TestOneof = NewPopulatedSampleOneOf_Field12(r, easy) + case 13: + this.TestOneof = NewPopulatedSampleOneOf_Field13(r, easy) + case 14: + this.TestOneof = NewPopulatedSampleOneOf_Field14(r, easy) + case 15: + this.TestOneof = NewPopulatedSampleOneOf_Field15(r, easy) + case 16: + this.TestOneof = NewPopulatedSampleOneOf_SubMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedSampleOneOf_Field1(r randyOne, easy bool) *SampleOneOf_Field1 { + this := &SampleOneOf_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field2(r randyOne, easy bool) *SampleOneOf_Field2 { + this := &SampleOneOf_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field3(r randyOne, easy bool) *SampleOneOf_Field3 { + this := &SampleOneOf_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field4(r randyOne, easy bool) *SampleOneOf_Field4 { + this := &SampleOneOf_Field4{} + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field5(r randyOne, easy bool) *SampleOneOf_Field5 { + this := &SampleOneOf_Field5{} + this.Field5 = uint32(r.Uint32()) + return this +} +func NewPopulatedSampleOneOf_Field6(r randyOne, easy bool) *SampleOneOf_Field6 { + this := &SampleOneOf_Field6{} + this.Field6 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedSampleOneOf_Field7(r randyOne, easy bool) *SampleOneOf_Field7 { + this := &SampleOneOf_Field7{} + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field8(r randyOne, easy bool) *SampleOneOf_Field8 { + this := &SampleOneOf_Field8{} + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field9(r randyOne, easy bool) *SampleOneOf_Field9 { + this := &SampleOneOf_Field9{} + this.Field9 = uint32(r.Uint32()) + return this +} +func NewPopulatedSampleOneOf_Field10(r randyOne, easy bool) *SampleOneOf_Field10 { + this := &SampleOneOf_Field10{} + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field11(r randyOne, easy bool) *SampleOneOf_Field11 { + this := &SampleOneOf_Field11{} + this.Field11 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedSampleOneOf_Field12(r randyOne, easy bool) *SampleOneOf_Field12 { + this := &SampleOneOf_Field12{} + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field13(r randyOne, easy bool) *SampleOneOf_Field13 { + this := &SampleOneOf_Field13{} + this.Field13 = bool(bool(r.Intn(2) == 0)) + return this +} +func NewPopulatedSampleOneOf_Field14(r randyOne, easy bool) *SampleOneOf_Field14 { + this := &SampleOneOf_Field14{} + this.Field14 = randStringOne(r) + return this +} +func NewPopulatedSampleOneOf_Field15(r randyOne, easy bool) *SampleOneOf_Field15 { + this := &SampleOneOf_Field15{} + v1 := r.Intn(100) + this.Field15 = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedSampleOneOf_SubMessage(r randyOne, easy bool) *SampleOneOf_SubMessage { + this := &SampleOneOf_SubMessage{} + this.SubMessage = NewPopulatedSubby(r, easy) + return this +} + +type randyOne interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneOne(r randyOne) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringOne(r randyOne) string { + v2 := r.Intn(100) + tmps := make([]rune, v2) + for i := 0; i < v2; i++ { + tmps[i] = randUTF8RuneOne(r) + } + return string(tmps) +} +func randUnrecognizedOne(r randyOne, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldOne(data, r, fieldNumber, wire) + } + return data +} +func randFieldOne(data []byte, r randyOne, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateOne(data, uint64(key)) + v3 := r.Int63() + if r.Intn(2) == 0 { + v3 *= -1 + } + data = encodeVarintPopulateOne(data, uint64(v3)) + case 1: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateOne(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateOne(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateOne(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Subby) Size() (n int) { + var l int + _ = l + l = len(m.Sub) + if l > 0 { + n += 1 + l + sovOne(uint64(l)) + } + return n +} + +func (m *SampleOneOf) Size() (n int) { + var l int + _ = l + if m.TestOneof != nil { + n += m.TestOneof.Size() + } + return n +} + +func (m *SampleOneOf_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *SampleOneOf_Field4) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field4)) + return n +} +func (m *SampleOneOf_Field5) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field5)) + return n +} +func (m *SampleOneOf_Field6) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field6)) + return n +} +func (m *SampleOneOf_Field7) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field7)) + return n +} +func (m *SampleOneOf_Field8) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field8)) + return n +} +func (m *SampleOneOf_Field9) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field10) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field11) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field12) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field13) Size() (n int) { + var l int + _ = l + n += 2 + return n +} +func (m *SampleOneOf_Field14) Size() (n int) { + var l int + _ = l + l = len(m.Field14) + n += 1 + l + sovOne(uint64(l)) + return n +} +func (m *SampleOneOf_Field15) Size() (n int) { + var l int + _ = l + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovOne(uint64(l)) + } + return n +} +func (m *SampleOneOf_SubMessage) Size() (n int) { + var l int + _ = l + if m.SubMessage != nil { + l = m.SubMessage.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} + +func sovOne(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozOne(x uint64) (n int) { + return sovOne(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Subby) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Subby{`, + `Sub:` + fmt.Sprintf("%v", this.Sub) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf{`, + `TestOneof:` + fmt.Sprintf("%v", this.TestOneof) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field4) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field4{`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field5) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field5{`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field6) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field6{`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field7) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field7{`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field8) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field8{`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field9) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field9{`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field10) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field10{`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field11) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field11{`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field12) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field12{`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field13) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field13{`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field14) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field14{`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field15) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field15{`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_SubMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_SubMessage{`, + `SubMessage:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func valueToStringOne(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/neither/one.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/neither/one.proto new file mode 100644 index 0000000000000000000000000000000000000000..c3cdff7e5e653d662e360759738af0d5bced9860 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/neither/one.proto @@ -0,0 +1,80 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 one; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Subby { + string sub = 1; +} + +message SampleOneOf { + oneof test_oneof { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + int64 Field4 = 4; + uint32 Field5 = 5; + uint64 Field6 = 6; + sint32 Field7 = 7; + sint64 Field8 = 8; + fixed32 Field9 = 9; + sfixed32 Field10 = 10; + fixed64 Field11 = 11; + sfixed64 Field12 = 12; + bool Field13 = 13; + string Field14 = 14; + bytes Field15 = 15; + Subby sub_message = 16; + } +} + + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/neither/onepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/neither/onepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..8967dc0fdf0d1fb9328fd10b67dc232fe9b861cc --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/neither/onepb_test.go @@ -0,0 +1,334 @@ +// Code generated by protoc-gen-gogo. +// source: combos/neither/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/neither/one.proto + +It has these top-level messages: + Subby + SampleOneOf +*/ +package one + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestSubbyProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSampleOneOfProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSubbyJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSampleOneOfJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSubbyProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOneDescription(t *testing.T) { + OneDescription() +} +func TestSubbyVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSampleOneOfVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSubbyGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSampleOneOfGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSubbySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSampleOneOfSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSubbyStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestSampleOneOfStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unmarshaler/one.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unmarshaler/one.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..5ed728089641a51aa1c2bb066b2f59f22155635c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unmarshaler/one.pb.go @@ -0,0 +1,4286 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unmarshaler/one.proto +// DO NOT EDIT! + +/* + Package one is a generated protocol buffer package. + + It is generated from these files: + combos/unmarshaler/one.proto + + It has these top-level messages: + Subby + SampleOneOf +*/ +package one + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Subby struct { + Sub string `protobuf:"bytes,1,opt,name=sub,proto3" json:"sub,omitempty"` +} + +func (m *Subby) Reset() { *m = Subby{} } +func (*Subby) ProtoMessage() {} + +type SampleOneOf struct { + // Types that are valid to be assigned to TestOneof: + // *SampleOneOf_Field1 + // *SampleOneOf_Field2 + // *SampleOneOf_Field3 + // *SampleOneOf_Field4 + // *SampleOneOf_Field5 + // *SampleOneOf_Field6 + // *SampleOneOf_Field7 + // *SampleOneOf_Field8 + // *SampleOneOf_Field9 + // *SampleOneOf_Field10 + // *SampleOneOf_Field11 + // *SampleOneOf_Field12 + // *SampleOneOf_Field13 + // *SampleOneOf_Field14 + // *SampleOneOf_Field15 + // *SampleOneOf_SubMessage + TestOneof isSampleOneOf_TestOneof `protobuf_oneof:"test_oneof"` +} + +func (m *SampleOneOf) Reset() { *m = SampleOneOf{} } +func (*SampleOneOf) ProtoMessage() {} + +type isSampleOneOf_TestOneof interface { + isSampleOneOf_TestOneof() + Equal(interface{}) bool + VerboseEqual(interface{}) error + Size() int +} + +type SampleOneOf_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,proto3,oneof"` +} +type SampleOneOf_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,proto3,oneof"` +} +type SampleOneOf_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,proto3,oneof"` +} +type SampleOneOf_Field4 struct { + Field4 int64 `protobuf:"varint,4,opt,name=Field4,proto3,oneof"` +} +type SampleOneOf_Field5 struct { + Field5 uint32 `protobuf:"varint,5,opt,name=Field5,proto3,oneof"` +} +type SampleOneOf_Field6 struct { + Field6 uint64 `protobuf:"varint,6,opt,name=Field6,proto3,oneof"` +} +type SampleOneOf_Field7 struct { + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7,proto3,oneof"` +} +type SampleOneOf_Field8 struct { + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8,proto3,oneof"` +} +type SampleOneOf_Field9 struct { + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9,proto3,oneof"` +} +type SampleOneOf_Field10 struct { + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10,proto3,oneof"` +} +type SampleOneOf_Field11 struct { + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11,proto3,oneof"` +} +type SampleOneOf_Field12 struct { + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12,proto3,oneof"` +} +type SampleOneOf_Field13 struct { + Field13 bool `protobuf:"varint,13,opt,name=Field13,proto3,oneof"` +} +type SampleOneOf_Field14 struct { + Field14 string `protobuf:"bytes,14,opt,name=Field14,proto3,oneof"` +} +type SampleOneOf_Field15 struct { + Field15 []byte `protobuf:"bytes,15,opt,name=Field15,proto3,oneof"` +} +type SampleOneOf_SubMessage struct { + SubMessage *Subby `protobuf:"bytes,16,opt,name=sub_message,oneof"` +} + +func (*SampleOneOf_Field1) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field2) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field3) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field4) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field5) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field6) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field7) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field8) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field9) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field10) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field11) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field12) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field13) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field14) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field15) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_SubMessage) isSampleOneOf_TestOneof() {} + +func (m *SampleOneOf) GetTestOneof() isSampleOneOf_TestOneof { + if m != nil { + return m.TestOneof + } + return nil +} + +func (m *SampleOneOf) GetField1() float64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *SampleOneOf) GetField2() float32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *SampleOneOf) GetField3() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *SampleOneOf) GetField4() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field4); ok { + return x.Field4 + } + return 0 +} + +func (m *SampleOneOf) GetField5() uint32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field5); ok { + return x.Field5 + } + return 0 +} + +func (m *SampleOneOf) GetField6() uint64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field6); ok { + return x.Field6 + } + return 0 +} + +func (m *SampleOneOf) GetField7() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field7); ok { + return x.Field7 + } + return 0 +} + +func (m *SampleOneOf) GetField8() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field8); ok { + return x.Field8 + } + return 0 +} + +func (m *SampleOneOf) GetField9() uint32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field9); ok { + return x.Field9 + } + return 0 +} + +func (m *SampleOneOf) GetField10() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field10); ok { + return x.Field10 + } + return 0 +} + +func (m *SampleOneOf) GetField11() uint64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field11); ok { + return x.Field11 + } + return 0 +} + +func (m *SampleOneOf) GetField12() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field12); ok { + return x.Field12 + } + return 0 +} + +func (m *SampleOneOf) GetField13() bool { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field13); ok { + return x.Field13 + } + return false +} + +func (m *SampleOneOf) GetField14() string { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field14); ok { + return x.Field14 + } + return "" +} + +func (m *SampleOneOf) GetField15() []byte { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field15); ok { + return x.Field15 + } + return nil +} + +func (m *SampleOneOf) GetSubMessage() *Subby { + if x, ok := m.GetTestOneof().(*SampleOneOf_SubMessage); ok { + return x.SubMessage + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*SampleOneOf) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _SampleOneOf_OneofMarshaler, _SampleOneOf_OneofUnmarshaler, []interface{}{ + (*SampleOneOf_Field1)(nil), + (*SampleOneOf_Field2)(nil), + (*SampleOneOf_Field3)(nil), + (*SampleOneOf_Field4)(nil), + (*SampleOneOf_Field5)(nil), + (*SampleOneOf_Field6)(nil), + (*SampleOneOf_Field7)(nil), + (*SampleOneOf_Field8)(nil), + (*SampleOneOf_Field9)(nil), + (*SampleOneOf_Field10)(nil), + (*SampleOneOf_Field11)(nil), + (*SampleOneOf_Field12)(nil), + (*SampleOneOf_Field13)(nil), + (*SampleOneOf_Field14)(nil), + (*SampleOneOf_Field15)(nil), + (*SampleOneOf_SubMessage)(nil), + } +} + +func _SampleOneOf_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*SampleOneOf) + // test_oneof + switch x := m.TestOneof.(type) { + case *SampleOneOf_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *SampleOneOf_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *SampleOneOf_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case *SampleOneOf_Field4: + _ = b.EncodeVarint(4<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field4)) + case *SampleOneOf_Field5: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field5)) + case *SampleOneOf_Field6: + _ = b.EncodeVarint(6<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field6)) + case *SampleOneOf_Field7: + _ = b.EncodeVarint(7<<3 | proto.WireVarint) + _ = b.EncodeZigzag32(uint64(x.Field7)) + case *SampleOneOf_Field8: + _ = b.EncodeVarint(8<<3 | proto.WireVarint) + _ = b.EncodeZigzag64(uint64(x.Field8)) + case *SampleOneOf_Field9: + _ = b.EncodeVarint(9<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field9)) + case *SampleOneOf_Field10: + _ = b.EncodeVarint(10<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field10)) + case *SampleOneOf_Field11: + _ = b.EncodeVarint(11<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field11)) + case *SampleOneOf_Field12: + _ = b.EncodeVarint(12<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field12)) + case *SampleOneOf_Field13: + t := uint64(0) + if x.Field13 { + t = 1 + } + _ = b.EncodeVarint(13<<3 | proto.WireVarint) + _ = b.EncodeVarint(t) + case *SampleOneOf_Field14: + _ = b.EncodeVarint(14<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field14) + case *SampleOneOf_Field15: + _ = b.EncodeVarint(15<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field15) + case *SampleOneOf_SubMessage: + _ = b.EncodeVarint(16<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("SampleOneOf.TestOneof has unexpected type %T", x) + } + return nil +} + +func _SampleOneOf_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*SampleOneOf) + switch tag { + case 1: // test_oneof.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field1{math.Float64frombits(x)} + return true, err + case 2: // test_oneof.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // test_oneof.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field3{int32(x)} + return true, err + case 4: // test_oneof.Field4 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field4{int64(x)} + return true, err + case 5: // test_oneof.Field5 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field5{uint32(x)} + return true, err + case 6: // test_oneof.Field6 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field6{x} + return true, err + case 7: // test_oneof.Field7 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag32() + m.TestOneof = &SampleOneOf_Field7{int32(x)} + return true, err + case 8: // test_oneof.Field8 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag64() + m.TestOneof = &SampleOneOf_Field8{int64(x)} + return true, err + case 9: // test_oneof.Field9 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field9{uint32(x)} + return true, err + case 10: // test_oneof.Field10 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field10{int32(x)} + return true, err + case 11: // test_oneof.Field11 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field11{x} + return true, err + case 12: // test_oneof.Field12 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field12{int64(x)} + return true, err + case 13: // test_oneof.Field13 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field13{x != 0} + return true, err + case 14: // test_oneof.Field14 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.TestOneof = &SampleOneOf_Field14{x} + return true, err + case 15: // test_oneof.Field15 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.TestOneof = &SampleOneOf_Field15{x} + return true, err + case 16: // test_oneof.sub_message + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.TestOneof = &SampleOneOf_SubMessage{msg} + return true, err + default: + return false, nil + } +} + +func (this *Subby) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *SampleOneOf) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func OneDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unmarshaler/one.proto"), + Package: func(v string) *string { return &v }("one"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Subby"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("sub"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("SampleOneOf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("sub_message"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(0), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("test_oneof")}}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + Syntax: func(v string) *string { return &v }("proto3"), + }}, + } +} +func (this *Subby) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Subby) + if !ok { + return fmt.Errorf("that is not of type *Subby") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Subby but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Subbybut is not nil && this == nil") + } + if this.Sub != that1.Sub { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) + } + return nil +} +func (this *Subby) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Subby) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Sub != that1.Sub { + return false + } + return true +} +func (this *SampleOneOf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOfbut is not nil && this == nil") + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return fmt.Errorf("this.TestOneof != nil && that1.TestOneof == nil") + } + } else if this.TestOneof == nil { + return fmt.Errorf("this.TestOneof == nil && that1.TestOneof != nil") + } else if err := this.TestOneof.VerboseEqual(that1.TestOneof); err != nil { + return err + } + return nil +} +func (this *SampleOneOf_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field1) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *SampleOneOf_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field2) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *SampleOneOf_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field3) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *SampleOneOf_Field4) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field4) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field4") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field4 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field4but is not nil && this == nil") + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + return nil +} +func (this *SampleOneOf_Field5) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field5) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field5") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field5 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field5but is not nil && this == nil") + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + return nil +} +func (this *SampleOneOf_Field6) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field6) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field6") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field6 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field6but is not nil && this == nil") + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + return nil +} +func (this *SampleOneOf_Field7) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field7) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field7") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field7 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field7but is not nil && this == nil") + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + return nil +} +func (this *SampleOneOf_Field8) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field8) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field8") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field8 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field8but is not nil && this == nil") + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + return nil +} +func (this *SampleOneOf_Field9) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field9) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field9") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field9 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field9but is not nil && this == nil") + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + return nil +} +func (this *SampleOneOf_Field10) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field10) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field10") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field10 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field10but is not nil && this == nil") + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + return nil +} +func (this *SampleOneOf_Field11) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field11) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field11") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field11 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field11but is not nil && this == nil") + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + return nil +} +func (this *SampleOneOf_Field12) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field12) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field12") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field12 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field12but is not nil && this == nil") + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + return nil +} +func (this *SampleOneOf_Field13) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field13) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field13") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field13 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field13but is not nil && this == nil") + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + return nil +} +func (this *SampleOneOf_Field14) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field14) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field14") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field14 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field14but is not nil && this == nil") + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + return nil +} +func (this *SampleOneOf_Field15) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field15) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field15") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field15 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field15but is not nil && this == nil") + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + return nil +} +func (this *SampleOneOf_SubMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_SubMessage) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_SubMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_SubMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_SubMessagebut is not nil && this == nil") + } + if !this.SubMessage.Equal(that1.SubMessage) { + return fmt.Errorf("SubMessage this(%v) Not Equal that(%v)", this.SubMessage, that1.SubMessage) + } + return nil +} +func (this *SampleOneOf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return false + } + } else if this.TestOneof == nil { + return false + } else if !this.TestOneof.Equal(that1.TestOneof) { + return false + } + return true +} +func (this *SampleOneOf_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *SampleOneOf_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *SampleOneOf_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *SampleOneOf_Field4) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field4) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field4 != that1.Field4 { + return false + } + return true +} +func (this *SampleOneOf_Field5) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field5) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field5 != that1.Field5 { + return false + } + return true +} +func (this *SampleOneOf_Field6) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field6) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field6 != that1.Field6 { + return false + } + return true +} +func (this *SampleOneOf_Field7) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field7) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field7 != that1.Field7 { + return false + } + return true +} +func (this *SampleOneOf_Field8) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field8) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field8 != that1.Field8 { + return false + } + return true +} +func (this *SampleOneOf_Field9) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field9) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field9 != that1.Field9 { + return false + } + return true +} +func (this *SampleOneOf_Field10) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field10) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field10 != that1.Field10 { + return false + } + return true +} +func (this *SampleOneOf_Field11) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field11) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field11 != that1.Field11 { + return false + } + return true +} +func (this *SampleOneOf_Field12) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field12) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field12 != that1.Field12 { + return false + } + return true +} +func (this *SampleOneOf_Field13) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field13) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field13 != that1.Field13 { + return false + } + return true +} +func (this *SampleOneOf_Field14) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field14) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field14 != that1.Field14 { + return false + } + return true +} +func (this *SampleOneOf_Field15) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field15) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + return true +} +func (this *SampleOneOf_SubMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_SubMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage.Equal(that1.SubMessage) { + return false + } + return true +} +func (this *Subby) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&one.Subby{") + s = append(s, "Sub: "+fmt.Sprintf("%#v", this.Sub)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SampleOneOf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 20) + s = append(s, "&one.SampleOneOf{") + if this.TestOneof != nil { + s = append(s, "TestOneof: "+fmt.Sprintf("%#v", this.TestOneof)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SampleOneOf_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field4) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field4{` + + `Field4:` + fmt.Sprintf("%#v", this.Field4) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field5) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field5{` + + `Field5:` + fmt.Sprintf("%#v", this.Field5) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field6) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field6{` + + `Field6:` + fmt.Sprintf("%#v", this.Field6) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field7) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field7{` + + `Field7:` + fmt.Sprintf("%#v", this.Field7) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field8) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field8{` + + `Field8:` + fmt.Sprintf("%#v", this.Field8) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field9) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field9{` + + `Field9:` + fmt.Sprintf("%#v", this.Field9) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field10) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field10{` + + `Field10:` + fmt.Sprintf("%#v", this.Field10) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field11) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field11{` + + `Field11:` + fmt.Sprintf("%#v", this.Field11) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field12) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field12{` + + `Field12:` + fmt.Sprintf("%#v", this.Field12) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field13) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field13{` + + `Field13:` + fmt.Sprintf("%#v", this.Field13) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field14) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field14{` + + `Field14:` + fmt.Sprintf("%#v", this.Field14) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field15) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field15{` + + `Field15:` + fmt.Sprintf("%#v", this.Field15) + `}`}, ", ") + return s +} +func (this *SampleOneOf_SubMessage) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_SubMessage{` + + `SubMessage:` + fmt.Sprintf("%#v", this.SubMessage) + `}`}, ", ") + return s +} +func valueToGoStringOne(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringOne(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedSubby(r randyOne, easy bool) *Subby { + this := &Subby{} + this.Sub = randStringOne(r) + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedSampleOneOf(r randyOne, easy bool) *SampleOneOf { + this := &SampleOneOf{} + oneofNumber_TestOneof := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}[r.Intn(16)] + switch oneofNumber_TestOneof { + case 1: + this.TestOneof = NewPopulatedSampleOneOf_Field1(r, easy) + case 2: + this.TestOneof = NewPopulatedSampleOneOf_Field2(r, easy) + case 3: + this.TestOneof = NewPopulatedSampleOneOf_Field3(r, easy) + case 4: + this.TestOneof = NewPopulatedSampleOneOf_Field4(r, easy) + case 5: + this.TestOneof = NewPopulatedSampleOneOf_Field5(r, easy) + case 6: + this.TestOneof = NewPopulatedSampleOneOf_Field6(r, easy) + case 7: + this.TestOneof = NewPopulatedSampleOneOf_Field7(r, easy) + case 8: + this.TestOneof = NewPopulatedSampleOneOf_Field8(r, easy) + case 9: + this.TestOneof = NewPopulatedSampleOneOf_Field9(r, easy) + case 10: + this.TestOneof = NewPopulatedSampleOneOf_Field10(r, easy) + case 11: + this.TestOneof = NewPopulatedSampleOneOf_Field11(r, easy) + case 12: + this.TestOneof = NewPopulatedSampleOneOf_Field12(r, easy) + case 13: + this.TestOneof = NewPopulatedSampleOneOf_Field13(r, easy) + case 14: + this.TestOneof = NewPopulatedSampleOneOf_Field14(r, easy) + case 15: + this.TestOneof = NewPopulatedSampleOneOf_Field15(r, easy) + case 16: + this.TestOneof = NewPopulatedSampleOneOf_SubMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedSampleOneOf_Field1(r randyOne, easy bool) *SampleOneOf_Field1 { + this := &SampleOneOf_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field2(r randyOne, easy bool) *SampleOneOf_Field2 { + this := &SampleOneOf_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field3(r randyOne, easy bool) *SampleOneOf_Field3 { + this := &SampleOneOf_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field4(r randyOne, easy bool) *SampleOneOf_Field4 { + this := &SampleOneOf_Field4{} + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field5(r randyOne, easy bool) *SampleOneOf_Field5 { + this := &SampleOneOf_Field5{} + this.Field5 = uint32(r.Uint32()) + return this +} +func NewPopulatedSampleOneOf_Field6(r randyOne, easy bool) *SampleOneOf_Field6 { + this := &SampleOneOf_Field6{} + this.Field6 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedSampleOneOf_Field7(r randyOne, easy bool) *SampleOneOf_Field7 { + this := &SampleOneOf_Field7{} + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field8(r randyOne, easy bool) *SampleOneOf_Field8 { + this := &SampleOneOf_Field8{} + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field9(r randyOne, easy bool) *SampleOneOf_Field9 { + this := &SampleOneOf_Field9{} + this.Field9 = uint32(r.Uint32()) + return this +} +func NewPopulatedSampleOneOf_Field10(r randyOne, easy bool) *SampleOneOf_Field10 { + this := &SampleOneOf_Field10{} + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field11(r randyOne, easy bool) *SampleOneOf_Field11 { + this := &SampleOneOf_Field11{} + this.Field11 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedSampleOneOf_Field12(r randyOne, easy bool) *SampleOneOf_Field12 { + this := &SampleOneOf_Field12{} + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field13(r randyOne, easy bool) *SampleOneOf_Field13 { + this := &SampleOneOf_Field13{} + this.Field13 = bool(bool(r.Intn(2) == 0)) + return this +} +func NewPopulatedSampleOneOf_Field14(r randyOne, easy bool) *SampleOneOf_Field14 { + this := &SampleOneOf_Field14{} + this.Field14 = randStringOne(r) + return this +} +func NewPopulatedSampleOneOf_Field15(r randyOne, easy bool) *SampleOneOf_Field15 { + this := &SampleOneOf_Field15{} + v1 := r.Intn(100) + this.Field15 = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedSampleOneOf_SubMessage(r randyOne, easy bool) *SampleOneOf_SubMessage { + this := &SampleOneOf_SubMessage{} + this.SubMessage = NewPopulatedSubby(r, easy) + return this +} + +type randyOne interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneOne(r randyOne) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringOne(r randyOne) string { + v2 := r.Intn(100) + tmps := make([]rune, v2) + for i := 0; i < v2; i++ { + tmps[i] = randUTF8RuneOne(r) + } + return string(tmps) +} +func randUnrecognizedOne(r randyOne, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldOne(data, r, fieldNumber, wire) + } + return data +} +func randFieldOne(data []byte, r randyOne, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateOne(data, uint64(key)) + v3 := r.Int63() + if r.Intn(2) == 0 { + v3 *= -1 + } + data = encodeVarintPopulateOne(data, uint64(v3)) + case 1: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateOne(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateOne(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateOne(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Subby) Size() (n int) { + var l int + _ = l + l = len(m.Sub) + if l > 0 { + n += 1 + l + sovOne(uint64(l)) + } + return n +} + +func (m *SampleOneOf) Size() (n int) { + var l int + _ = l + if m.TestOneof != nil { + n += m.TestOneof.Size() + } + return n +} + +func (m *SampleOneOf_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *SampleOneOf_Field4) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field4)) + return n +} +func (m *SampleOneOf_Field5) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field5)) + return n +} +func (m *SampleOneOf_Field6) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field6)) + return n +} +func (m *SampleOneOf_Field7) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field7)) + return n +} +func (m *SampleOneOf_Field8) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field8)) + return n +} +func (m *SampleOneOf_Field9) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field10) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field11) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field12) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field13) Size() (n int) { + var l int + _ = l + n += 2 + return n +} +func (m *SampleOneOf_Field14) Size() (n int) { + var l int + _ = l + l = len(m.Field14) + n += 1 + l + sovOne(uint64(l)) + return n +} +func (m *SampleOneOf_Field15) Size() (n int) { + var l int + _ = l + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovOne(uint64(l)) + } + return n +} +func (m *SampleOneOf_SubMessage) Size() (n int) { + var l int + _ = l + if m.SubMessage != nil { + l = m.SubMessage.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} + +func sovOne(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozOne(x uint64) (n int) { + return sovOne(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Subby) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Subby{`, + `Sub:` + fmt.Sprintf("%v", this.Sub) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf{`, + `TestOneof:` + fmt.Sprintf("%v", this.TestOneof) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field4) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field4{`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field5) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field5{`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field6) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field6{`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field7) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field7{`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field8) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field8{`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field9) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field9{`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field10) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field10{`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field11) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field11{`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field12) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field12{`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field13) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field13{`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field14) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field14{`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field15) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field15{`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_SubMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_SubMessage{`, + `SubMessage:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func valueToStringOne(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Subby) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Subby: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Subby: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sub", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sub = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOne(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOne + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SampleOneOf) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SampleOneOf: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SampleOneOf: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.TestOneof = &SampleOneOf_Field1{float64(math.Float64frombits(v))} + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.TestOneof = &SampleOneOf_Field2{float32(math.Float32frombits(v))} + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &SampleOneOf_Field3{v} + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &SampleOneOf_Field4{v} + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &SampleOneOf_Field5{v} + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &SampleOneOf_Field6{v} + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.TestOneof = &SampleOneOf_Field7{v} + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.TestOneof = &SampleOneOf_Field8{int64(v)} + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.TestOneof = &SampleOneOf_Field9{v} + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.TestOneof = &SampleOneOf_Field10{v} + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.TestOneof = &SampleOneOf_Field11{v} + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.TestOneof = &SampleOneOf_Field12{v} + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.TestOneof = &SampleOneOf_Field13{b} + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TestOneof = &SampleOneOf_Field14{string(data[iNdEx:postIndex])} + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := make([]byte, postIndex-iNdEx) + copy(v, data[iNdEx:postIndex]) + m.TestOneof = &SampleOneOf_Field15{v} + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOne + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthOne + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &Subby{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.TestOneof = &SampleOneOf_SubMessage{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOne(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOne + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipOne(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOne + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOne + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOne + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthOne + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOne + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipOne(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthOne = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowOne = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unmarshaler/one.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unmarshaler/one.proto new file mode 100644 index 0000000000000000000000000000000000000000..87d6062402a824eb75d4318435bb59357ccaed9b --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unmarshaler/one.proto @@ -0,0 +1,80 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 one; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Subby { + string sub = 1; +} + +message SampleOneOf { + oneof test_oneof { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + int64 Field4 = 4; + uint32 Field5 = 5; + uint64 Field6 = 6; + sint32 Field7 = 7; + sint64 Field8 = 8; + fixed32 Field9 = 9; + sfixed32 Field10 = 10; + fixed64 Field11 = 11; + sfixed64 Field12 = 12; + bool Field13 = 13; + string Field14 = 14; + bytes Field15 = 15; + Subby sub_message = 16; + } +} + + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unmarshaler/onepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unmarshaler/onepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..53727c831e22534d2421fb008f134d136c5c7d55 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unmarshaler/onepb_test.go @@ -0,0 +1,334 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unmarshaler/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/unmarshaler/one.proto + +It has these top-level messages: + Subby + SampleOneOf +*/ +package one + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestSubbyProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSampleOneOfProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSubbyJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSampleOneOfJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSubbyProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOneDescription(t *testing.T) { + OneDescription() +} +func TestSubbyVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSampleOneOfVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSubbyGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSampleOneOfGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSubbySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSampleOneOfSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSubbyStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestSampleOneOfStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeboth/one.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeboth/one.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..ec43e1c806997c445545bb41080a2d79859f31de --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeboth/one.pb.go @@ -0,0 +1,4471 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeboth/one.proto +// DO NOT EDIT! + +/* + Package one is a generated protocol buffer package. + + It is generated from these files: + combos/unsafeboth/one.proto + + It has these top-level messages: + Subby + SampleOneOf +*/ +package one + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import unsafe "unsafe" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Subby struct { + Sub string `protobuf:"bytes,1,opt,name=sub,proto3" json:"sub,omitempty"` +} + +func (m *Subby) Reset() { *m = Subby{} } +func (*Subby) ProtoMessage() {} + +type SampleOneOf struct { + // Types that are valid to be assigned to TestOneof: + // *SampleOneOf_Field1 + // *SampleOneOf_Field2 + // *SampleOneOf_Field3 + // *SampleOneOf_Field4 + // *SampleOneOf_Field5 + // *SampleOneOf_Field6 + // *SampleOneOf_Field7 + // *SampleOneOf_Field8 + // *SampleOneOf_Field9 + // *SampleOneOf_Field10 + // *SampleOneOf_Field11 + // *SampleOneOf_Field12 + // *SampleOneOf_Field13 + // *SampleOneOf_Field14 + // *SampleOneOf_Field15 + // *SampleOneOf_SubMessage + TestOneof isSampleOneOf_TestOneof `protobuf_oneof:"test_oneof"` +} + +func (m *SampleOneOf) Reset() { *m = SampleOneOf{} } +func (*SampleOneOf) ProtoMessage() {} + +type isSampleOneOf_TestOneof interface { + isSampleOneOf_TestOneof() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} + +type SampleOneOf_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,proto3,oneof"` +} +type SampleOneOf_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,proto3,oneof"` +} +type SampleOneOf_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,proto3,oneof"` +} +type SampleOneOf_Field4 struct { + Field4 int64 `protobuf:"varint,4,opt,name=Field4,proto3,oneof"` +} +type SampleOneOf_Field5 struct { + Field5 uint32 `protobuf:"varint,5,opt,name=Field5,proto3,oneof"` +} +type SampleOneOf_Field6 struct { + Field6 uint64 `protobuf:"varint,6,opt,name=Field6,proto3,oneof"` +} +type SampleOneOf_Field7 struct { + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7,proto3,oneof"` +} +type SampleOneOf_Field8 struct { + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8,proto3,oneof"` +} +type SampleOneOf_Field9 struct { + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9,proto3,oneof"` +} +type SampleOneOf_Field10 struct { + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10,proto3,oneof"` +} +type SampleOneOf_Field11 struct { + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11,proto3,oneof"` +} +type SampleOneOf_Field12 struct { + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12,proto3,oneof"` +} +type SampleOneOf_Field13 struct { + Field13 bool `protobuf:"varint,13,opt,name=Field13,proto3,oneof"` +} +type SampleOneOf_Field14 struct { + Field14 string `protobuf:"bytes,14,opt,name=Field14,proto3,oneof"` +} +type SampleOneOf_Field15 struct { + Field15 []byte `protobuf:"bytes,15,opt,name=Field15,proto3,oneof"` +} +type SampleOneOf_SubMessage struct { + SubMessage *Subby `protobuf:"bytes,16,opt,name=sub_message,oneof"` +} + +func (*SampleOneOf_Field1) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field2) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field3) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field4) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field5) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field6) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field7) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field8) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field9) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field10) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field11) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field12) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field13) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field14) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field15) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_SubMessage) isSampleOneOf_TestOneof() {} + +func (m *SampleOneOf) GetTestOneof() isSampleOneOf_TestOneof { + if m != nil { + return m.TestOneof + } + return nil +} + +func (m *SampleOneOf) GetField1() float64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *SampleOneOf) GetField2() float32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *SampleOneOf) GetField3() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *SampleOneOf) GetField4() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field4); ok { + return x.Field4 + } + return 0 +} + +func (m *SampleOneOf) GetField5() uint32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field5); ok { + return x.Field5 + } + return 0 +} + +func (m *SampleOneOf) GetField6() uint64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field6); ok { + return x.Field6 + } + return 0 +} + +func (m *SampleOneOf) GetField7() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field7); ok { + return x.Field7 + } + return 0 +} + +func (m *SampleOneOf) GetField8() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field8); ok { + return x.Field8 + } + return 0 +} + +func (m *SampleOneOf) GetField9() uint32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field9); ok { + return x.Field9 + } + return 0 +} + +func (m *SampleOneOf) GetField10() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field10); ok { + return x.Field10 + } + return 0 +} + +func (m *SampleOneOf) GetField11() uint64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field11); ok { + return x.Field11 + } + return 0 +} + +func (m *SampleOneOf) GetField12() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field12); ok { + return x.Field12 + } + return 0 +} + +func (m *SampleOneOf) GetField13() bool { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field13); ok { + return x.Field13 + } + return false +} + +func (m *SampleOneOf) GetField14() string { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field14); ok { + return x.Field14 + } + return "" +} + +func (m *SampleOneOf) GetField15() []byte { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field15); ok { + return x.Field15 + } + return nil +} + +func (m *SampleOneOf) GetSubMessage() *Subby { + if x, ok := m.GetTestOneof().(*SampleOneOf_SubMessage); ok { + return x.SubMessage + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*SampleOneOf) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _SampleOneOf_OneofMarshaler, _SampleOneOf_OneofUnmarshaler, []interface{}{ + (*SampleOneOf_Field1)(nil), + (*SampleOneOf_Field2)(nil), + (*SampleOneOf_Field3)(nil), + (*SampleOneOf_Field4)(nil), + (*SampleOneOf_Field5)(nil), + (*SampleOneOf_Field6)(nil), + (*SampleOneOf_Field7)(nil), + (*SampleOneOf_Field8)(nil), + (*SampleOneOf_Field9)(nil), + (*SampleOneOf_Field10)(nil), + (*SampleOneOf_Field11)(nil), + (*SampleOneOf_Field12)(nil), + (*SampleOneOf_Field13)(nil), + (*SampleOneOf_Field14)(nil), + (*SampleOneOf_Field15)(nil), + (*SampleOneOf_SubMessage)(nil), + } +} + +func _SampleOneOf_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*SampleOneOf) + // test_oneof + switch x := m.TestOneof.(type) { + case *SampleOneOf_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *SampleOneOf_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *SampleOneOf_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case *SampleOneOf_Field4: + _ = b.EncodeVarint(4<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field4)) + case *SampleOneOf_Field5: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field5)) + case *SampleOneOf_Field6: + _ = b.EncodeVarint(6<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field6)) + case *SampleOneOf_Field7: + _ = b.EncodeVarint(7<<3 | proto.WireVarint) + _ = b.EncodeZigzag32(uint64(x.Field7)) + case *SampleOneOf_Field8: + _ = b.EncodeVarint(8<<3 | proto.WireVarint) + _ = b.EncodeZigzag64(uint64(x.Field8)) + case *SampleOneOf_Field9: + _ = b.EncodeVarint(9<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field9)) + case *SampleOneOf_Field10: + _ = b.EncodeVarint(10<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field10)) + case *SampleOneOf_Field11: + _ = b.EncodeVarint(11<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field11)) + case *SampleOneOf_Field12: + _ = b.EncodeVarint(12<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field12)) + case *SampleOneOf_Field13: + t := uint64(0) + if x.Field13 { + t = 1 + } + _ = b.EncodeVarint(13<<3 | proto.WireVarint) + _ = b.EncodeVarint(t) + case *SampleOneOf_Field14: + _ = b.EncodeVarint(14<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field14) + case *SampleOneOf_Field15: + _ = b.EncodeVarint(15<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field15) + case *SampleOneOf_SubMessage: + _ = b.EncodeVarint(16<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("SampleOneOf.TestOneof has unexpected type %T", x) + } + return nil +} + +func _SampleOneOf_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*SampleOneOf) + switch tag { + case 1: // test_oneof.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field1{math.Float64frombits(x)} + return true, err + case 2: // test_oneof.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // test_oneof.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field3{int32(x)} + return true, err + case 4: // test_oneof.Field4 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field4{int64(x)} + return true, err + case 5: // test_oneof.Field5 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field5{uint32(x)} + return true, err + case 6: // test_oneof.Field6 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field6{x} + return true, err + case 7: // test_oneof.Field7 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag32() + m.TestOneof = &SampleOneOf_Field7{int32(x)} + return true, err + case 8: // test_oneof.Field8 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag64() + m.TestOneof = &SampleOneOf_Field8{int64(x)} + return true, err + case 9: // test_oneof.Field9 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field9{uint32(x)} + return true, err + case 10: // test_oneof.Field10 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field10{int32(x)} + return true, err + case 11: // test_oneof.Field11 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field11{x} + return true, err + case 12: // test_oneof.Field12 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field12{int64(x)} + return true, err + case 13: // test_oneof.Field13 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field13{x != 0} + return true, err + case 14: // test_oneof.Field14 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.TestOneof = &SampleOneOf_Field14{x} + return true, err + case 15: // test_oneof.Field15 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.TestOneof = &SampleOneOf_Field15{x} + return true, err + case 16: // test_oneof.sub_message + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.TestOneof = &SampleOneOf_SubMessage{msg} + return true, err + default: + return false, nil + } +} + +func (this *Subby) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *SampleOneOf) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func OneDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unsafeboth/one.proto"), + Package: func(v string) *string { return &v }("one"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Subby"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("sub"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("SampleOneOf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("sub_message"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(0), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("test_oneof")}}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x1}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x1})}}, + Syntax: func(v string) *string { return &v }("proto3"), + }}, + } +} +func (this *Subby) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Subby) + if !ok { + return fmt.Errorf("that is not of type *Subby") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Subby but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Subbybut is not nil && this == nil") + } + if this.Sub != that1.Sub { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) + } + return nil +} +func (this *Subby) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Subby) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Sub != that1.Sub { + return false + } + return true +} +func (this *SampleOneOf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOfbut is not nil && this == nil") + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return fmt.Errorf("this.TestOneof != nil && that1.TestOneof == nil") + } + } else if this.TestOneof == nil { + return fmt.Errorf("this.TestOneof == nil && that1.TestOneof != nil") + } else if err := this.TestOneof.VerboseEqual(that1.TestOneof); err != nil { + return err + } + return nil +} +func (this *SampleOneOf_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field1) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *SampleOneOf_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field2) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *SampleOneOf_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field3) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *SampleOneOf_Field4) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field4) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field4") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field4 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field4but is not nil && this == nil") + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + return nil +} +func (this *SampleOneOf_Field5) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field5) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field5") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field5 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field5but is not nil && this == nil") + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + return nil +} +func (this *SampleOneOf_Field6) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field6) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field6") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field6 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field6but is not nil && this == nil") + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + return nil +} +func (this *SampleOneOf_Field7) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field7) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field7") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field7 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field7but is not nil && this == nil") + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + return nil +} +func (this *SampleOneOf_Field8) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field8) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field8") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field8 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field8but is not nil && this == nil") + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + return nil +} +func (this *SampleOneOf_Field9) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field9) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field9") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field9 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field9but is not nil && this == nil") + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + return nil +} +func (this *SampleOneOf_Field10) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field10) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field10") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field10 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field10but is not nil && this == nil") + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + return nil +} +func (this *SampleOneOf_Field11) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field11) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field11") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field11 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field11but is not nil && this == nil") + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + return nil +} +func (this *SampleOneOf_Field12) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field12) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field12") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field12 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field12but is not nil && this == nil") + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + return nil +} +func (this *SampleOneOf_Field13) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field13) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field13") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field13 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field13but is not nil && this == nil") + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + return nil +} +func (this *SampleOneOf_Field14) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field14) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field14") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field14 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field14but is not nil && this == nil") + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + return nil +} +func (this *SampleOneOf_Field15) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field15) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field15") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field15 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field15but is not nil && this == nil") + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + return nil +} +func (this *SampleOneOf_SubMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_SubMessage) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_SubMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_SubMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_SubMessagebut is not nil && this == nil") + } + if !this.SubMessage.Equal(that1.SubMessage) { + return fmt.Errorf("SubMessage this(%v) Not Equal that(%v)", this.SubMessage, that1.SubMessage) + } + return nil +} +func (this *SampleOneOf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return false + } + } else if this.TestOneof == nil { + return false + } else if !this.TestOneof.Equal(that1.TestOneof) { + return false + } + return true +} +func (this *SampleOneOf_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *SampleOneOf_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *SampleOneOf_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *SampleOneOf_Field4) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field4) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field4 != that1.Field4 { + return false + } + return true +} +func (this *SampleOneOf_Field5) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field5) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field5 != that1.Field5 { + return false + } + return true +} +func (this *SampleOneOf_Field6) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field6) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field6 != that1.Field6 { + return false + } + return true +} +func (this *SampleOneOf_Field7) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field7) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field7 != that1.Field7 { + return false + } + return true +} +func (this *SampleOneOf_Field8) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field8) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field8 != that1.Field8 { + return false + } + return true +} +func (this *SampleOneOf_Field9) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field9) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field9 != that1.Field9 { + return false + } + return true +} +func (this *SampleOneOf_Field10) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field10) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field10 != that1.Field10 { + return false + } + return true +} +func (this *SampleOneOf_Field11) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field11) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field11 != that1.Field11 { + return false + } + return true +} +func (this *SampleOneOf_Field12) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field12) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field12 != that1.Field12 { + return false + } + return true +} +func (this *SampleOneOf_Field13) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field13) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field13 != that1.Field13 { + return false + } + return true +} +func (this *SampleOneOf_Field14) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field14) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field14 != that1.Field14 { + return false + } + return true +} +func (this *SampleOneOf_Field15) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field15) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + return true +} +func (this *SampleOneOf_SubMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_SubMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage.Equal(that1.SubMessage) { + return false + } + return true +} +func (this *Subby) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&one.Subby{") + s = append(s, "Sub: "+fmt.Sprintf("%#v", this.Sub)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SampleOneOf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 20) + s = append(s, "&one.SampleOneOf{") + if this.TestOneof != nil { + s = append(s, "TestOneof: "+fmt.Sprintf("%#v", this.TestOneof)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SampleOneOf_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field4) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field4{` + + `Field4:` + fmt.Sprintf("%#v", this.Field4) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field5) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field5{` + + `Field5:` + fmt.Sprintf("%#v", this.Field5) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field6) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field6{` + + `Field6:` + fmt.Sprintf("%#v", this.Field6) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field7) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field7{` + + `Field7:` + fmt.Sprintf("%#v", this.Field7) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field8) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field8{` + + `Field8:` + fmt.Sprintf("%#v", this.Field8) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field9) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field9{` + + `Field9:` + fmt.Sprintf("%#v", this.Field9) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field10) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field10{` + + `Field10:` + fmt.Sprintf("%#v", this.Field10) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field11) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field11{` + + `Field11:` + fmt.Sprintf("%#v", this.Field11) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field12) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field12{` + + `Field12:` + fmt.Sprintf("%#v", this.Field12) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field13) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field13{` + + `Field13:` + fmt.Sprintf("%#v", this.Field13) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field14) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field14{` + + `Field14:` + fmt.Sprintf("%#v", this.Field14) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field15) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field15{` + + `Field15:` + fmt.Sprintf("%#v", this.Field15) + `}`}, ", ") + return s +} +func (this *SampleOneOf_SubMessage) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_SubMessage{` + + `SubMessage:` + fmt.Sprintf("%#v", this.SubMessage) + `}`}, ", ") + return s +} +func valueToGoStringOne(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringOne(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedSubby(r randyOne, easy bool) *Subby { + this := &Subby{} + this.Sub = randStringOne(r) + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedSampleOneOf(r randyOne, easy bool) *SampleOneOf { + this := &SampleOneOf{} + oneofNumber_TestOneof := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}[r.Intn(16)] + switch oneofNumber_TestOneof { + case 1: + this.TestOneof = NewPopulatedSampleOneOf_Field1(r, easy) + case 2: + this.TestOneof = NewPopulatedSampleOneOf_Field2(r, easy) + case 3: + this.TestOneof = NewPopulatedSampleOneOf_Field3(r, easy) + case 4: + this.TestOneof = NewPopulatedSampleOneOf_Field4(r, easy) + case 5: + this.TestOneof = NewPopulatedSampleOneOf_Field5(r, easy) + case 6: + this.TestOneof = NewPopulatedSampleOneOf_Field6(r, easy) + case 7: + this.TestOneof = NewPopulatedSampleOneOf_Field7(r, easy) + case 8: + this.TestOneof = NewPopulatedSampleOneOf_Field8(r, easy) + case 9: + this.TestOneof = NewPopulatedSampleOneOf_Field9(r, easy) + case 10: + this.TestOneof = NewPopulatedSampleOneOf_Field10(r, easy) + case 11: + this.TestOneof = NewPopulatedSampleOneOf_Field11(r, easy) + case 12: + this.TestOneof = NewPopulatedSampleOneOf_Field12(r, easy) + case 13: + this.TestOneof = NewPopulatedSampleOneOf_Field13(r, easy) + case 14: + this.TestOneof = NewPopulatedSampleOneOf_Field14(r, easy) + case 15: + this.TestOneof = NewPopulatedSampleOneOf_Field15(r, easy) + case 16: + this.TestOneof = NewPopulatedSampleOneOf_SubMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedSampleOneOf_Field1(r randyOne, easy bool) *SampleOneOf_Field1 { + this := &SampleOneOf_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field2(r randyOne, easy bool) *SampleOneOf_Field2 { + this := &SampleOneOf_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field3(r randyOne, easy bool) *SampleOneOf_Field3 { + this := &SampleOneOf_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field4(r randyOne, easy bool) *SampleOneOf_Field4 { + this := &SampleOneOf_Field4{} + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field5(r randyOne, easy bool) *SampleOneOf_Field5 { + this := &SampleOneOf_Field5{} + this.Field5 = uint32(r.Uint32()) + return this +} +func NewPopulatedSampleOneOf_Field6(r randyOne, easy bool) *SampleOneOf_Field6 { + this := &SampleOneOf_Field6{} + this.Field6 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedSampleOneOf_Field7(r randyOne, easy bool) *SampleOneOf_Field7 { + this := &SampleOneOf_Field7{} + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field8(r randyOne, easy bool) *SampleOneOf_Field8 { + this := &SampleOneOf_Field8{} + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field9(r randyOne, easy bool) *SampleOneOf_Field9 { + this := &SampleOneOf_Field9{} + this.Field9 = uint32(r.Uint32()) + return this +} +func NewPopulatedSampleOneOf_Field10(r randyOne, easy bool) *SampleOneOf_Field10 { + this := &SampleOneOf_Field10{} + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field11(r randyOne, easy bool) *SampleOneOf_Field11 { + this := &SampleOneOf_Field11{} + this.Field11 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedSampleOneOf_Field12(r randyOne, easy bool) *SampleOneOf_Field12 { + this := &SampleOneOf_Field12{} + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field13(r randyOne, easy bool) *SampleOneOf_Field13 { + this := &SampleOneOf_Field13{} + this.Field13 = bool(bool(r.Intn(2) == 0)) + return this +} +func NewPopulatedSampleOneOf_Field14(r randyOne, easy bool) *SampleOneOf_Field14 { + this := &SampleOneOf_Field14{} + this.Field14 = randStringOne(r) + return this +} +func NewPopulatedSampleOneOf_Field15(r randyOne, easy bool) *SampleOneOf_Field15 { + this := &SampleOneOf_Field15{} + v1 := r.Intn(100) + this.Field15 = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedSampleOneOf_SubMessage(r randyOne, easy bool) *SampleOneOf_SubMessage { + this := &SampleOneOf_SubMessage{} + this.SubMessage = NewPopulatedSubby(r, easy) + return this +} + +type randyOne interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneOne(r randyOne) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringOne(r randyOne) string { + v2 := r.Intn(100) + tmps := make([]rune, v2) + for i := 0; i < v2; i++ { + tmps[i] = randUTF8RuneOne(r) + } + return string(tmps) +} +func randUnrecognizedOne(r randyOne, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldOne(data, r, fieldNumber, wire) + } + return data +} +func randFieldOne(data []byte, r randyOne, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateOne(data, uint64(key)) + v3 := r.Int63() + if r.Intn(2) == 0 { + v3 *= -1 + } + data = encodeVarintPopulateOne(data, uint64(v3)) + case 1: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateOne(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateOne(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateOne(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Subby) Size() (n int) { + var l int + _ = l + l = len(m.Sub) + if l > 0 { + n += 1 + l + sovOne(uint64(l)) + } + return n +} + +func (m *SampleOneOf) Size() (n int) { + var l int + _ = l + if m.TestOneof != nil { + n += m.TestOneof.Size() + } + return n +} + +func (m *SampleOneOf_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *SampleOneOf_Field4) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field4)) + return n +} +func (m *SampleOneOf_Field5) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field5)) + return n +} +func (m *SampleOneOf_Field6) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field6)) + return n +} +func (m *SampleOneOf_Field7) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field7)) + return n +} +func (m *SampleOneOf_Field8) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field8)) + return n +} +func (m *SampleOneOf_Field9) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field10) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field11) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field12) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field13) Size() (n int) { + var l int + _ = l + n += 2 + return n +} +func (m *SampleOneOf_Field14) Size() (n int) { + var l int + _ = l + l = len(m.Field14) + n += 1 + l + sovOne(uint64(l)) + return n +} +func (m *SampleOneOf_Field15) Size() (n int) { + var l int + _ = l + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovOne(uint64(l)) + } + return n +} +func (m *SampleOneOf_SubMessage) Size() (n int) { + var l int + _ = l + if m.SubMessage != nil { + l = m.SubMessage.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} + +func sovOne(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozOne(x uint64) (n int) { + return sovOne(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Subby) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Subby{`, + `Sub:` + fmt.Sprintf("%v", this.Sub) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf{`, + `TestOneof:` + fmt.Sprintf("%v", this.TestOneof) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field4) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field4{`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field5) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field5{`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field6) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field6{`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field7) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field7{`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field8) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field8{`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field9) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field9{`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field10) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field10{`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field11) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field11{`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field12) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field12{`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field13) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field13{`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field14) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field14{`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field15) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field15{`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_SubMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_SubMessage{`, + `SubMessage:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func valueToStringOne(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Subby) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Subby) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Sub) > 0 { + data[i] = 0xa + i++ + i = encodeVarintOne(data, i, uint64(len(m.Sub))) + i += copy(data[i:], m.Sub) + } + return i, nil +} + +func (m *SampleOneOf) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *SampleOneOf) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.TestOneof != nil { + nn1, err := m.TestOneof.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn1 + } + return i, nil +} + +func (m *SampleOneOf_Field1) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = m.Field1 + i += 8 + return i, nil +} +func (m *SampleOneOf_Field2) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = m.Field2 + i += 4 + return i, nil +} +func (m *SampleOneOf_Field3) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x18 + i++ + i = encodeVarintOne(data, i, uint64(m.Field3)) + return i, nil +} +func (m *SampleOneOf_Field4) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x20 + i++ + i = encodeVarintOne(data, i, uint64(m.Field4)) + return i, nil +} +func (m *SampleOneOf_Field5) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x28 + i++ + i = encodeVarintOne(data, i, uint64(m.Field5)) + return i, nil +} +func (m *SampleOneOf_Field6) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x30 + i++ + i = encodeVarintOne(data, i, uint64(m.Field6)) + return i, nil +} +func (m *SampleOneOf_Field7) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x38 + i++ + i = encodeVarintOne(data, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31)))) + return i, nil +} +func (m *SampleOneOf_Field8) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x40 + i++ + i = encodeVarintOne(data, i, uint64((uint64(m.Field8)<<1)^uint64((m.Field8>>63)))) + return i, nil +} +func (m *SampleOneOf_Field9) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = m.Field9 + i += 4 + return i, nil +} +func (m *SampleOneOf_Field10) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = m.Field10 + i += 4 + return i, nil +} +func (m *SampleOneOf_Field11) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = m.Field11 + i += 8 + return i, nil +} +func (m *SampleOneOf_Field12) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = m.Field12 + i += 8 + return i, nil +} +func (m *SampleOneOf_Field13) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x68 + i++ + if m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + return i, nil +} +func (m *SampleOneOf_Field14) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x72 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field14))) + i += copy(data[i:], m.Field14) + return i, nil +} +func (m *SampleOneOf_Field15) MarshalTo(data []byte) (int, error) { + i := 0 + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + return i, nil +} +func (m *SampleOneOf_SubMessage) MarshalTo(data []byte) (int, error) { + i := 0 + if m.SubMessage != nil { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + i = encodeVarintOne(data, i, uint64(m.SubMessage.Size())) + n2, err := m.SubMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + } + return i, nil +} +func encodeFixed64One(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32One(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintOne(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *Subby) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Subby: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Subby: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sub", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sub = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOneUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOneUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SampleOneOf) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SampleOneOf: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SampleOneOf: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.TestOneof = &SampleOneOf_Field1{v} + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.TestOneof = &SampleOneOf_Field2{v} + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &SampleOneOf_Field3{v} + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &SampleOneOf_Field4{v} + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &SampleOneOf_Field5{v} + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &SampleOneOf_Field6{v} + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.TestOneof = &SampleOneOf_Field7{v} + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.TestOneof = &SampleOneOf_Field8{int64(v)} + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.TestOneof = &SampleOneOf_Field9{v} + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.TestOneof = &SampleOneOf_Field10{v} + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.TestOneof = &SampleOneOf_Field11{v} + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.TestOneof = &SampleOneOf_Field12{v} + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.TestOneof = &SampleOneOf_Field13{b} + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TestOneof = &SampleOneOf_Field14{string(data[iNdEx:postIndex])} + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := make([]byte, postIndex-iNdEx) + copy(v, data[iNdEx:postIndex]) + m.TestOneof = &SampleOneOf_Field15{v} + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &Subby{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.TestOneof = &SampleOneOf_SubMessage{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOneUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOneUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipOneUnsafe(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthOneUnsafe + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipOneUnsafe(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthOneUnsafe = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowOneUnsafe = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeboth/one.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeboth/one.proto new file mode 100644 index 0000000000000000000000000000000000000000..112cabc202dad7a1bf45906491b93d104c31f216 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeboth/one.proto @@ -0,0 +1,80 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 one; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = true; +option (gogoproto.unsafe_unmarshaler_all) = true; + +message Subby { + string sub = 1; +} + +message SampleOneOf { + oneof test_oneof { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + int64 Field4 = 4; + uint32 Field5 = 5; + uint64 Field6 = 6; + sint32 Field7 = 7; + sint64 Field8 = 8; + fixed32 Field9 = 9; + sfixed32 Field10 = 10; + fixed64 Field11 = 11; + sfixed64 Field12 = 12; + bool Field13 = 13; + string Field14 = 14; + bytes Field15 = 15; + Subby sub_message = 16; + } +} + + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeboth/onepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeboth/onepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..01e6d9c52c65a1792d533d84c8d5bd576beb9826 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeboth/onepb_test.go @@ -0,0 +1,390 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeboth/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/unsafeboth/one.proto + +It has these top-level messages: + Subby + SampleOneOf +*/ +package one + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestSubbyProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSubbyMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSampleOneOfMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSampleOneOfJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSubbyProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOneDescription(t *testing.T) { + OneDescription() +} +func TestSubbyVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSampleOneOfVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSubbyGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSampleOneOfGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSubbySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSampleOneOfSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSubbyStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestSampleOneOfStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafemarshaler/one.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafemarshaler/one.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..6bbdc2728c52de5a3e8eae0677503e4f1a0f6ae8 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafemarshaler/one.pb.go @@ -0,0 +1,3936 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafemarshaler/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/unsafemarshaler/one.proto + +It has these top-level messages: + Subby + SampleOneOf +*/ +package one + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import unsafe "unsafe" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Subby struct { + Sub string `protobuf:"bytes,1,opt,name=sub,proto3" json:"sub,omitempty"` +} + +func (m *Subby) Reset() { *m = Subby{} } +func (*Subby) ProtoMessage() {} + +type SampleOneOf struct { + // Types that are valid to be assigned to TestOneof: + // *SampleOneOf_Field1 + // *SampleOneOf_Field2 + // *SampleOneOf_Field3 + // *SampleOneOf_Field4 + // *SampleOneOf_Field5 + // *SampleOneOf_Field6 + // *SampleOneOf_Field7 + // *SampleOneOf_Field8 + // *SampleOneOf_Field9 + // *SampleOneOf_Field10 + // *SampleOneOf_Field11 + // *SampleOneOf_Field12 + // *SampleOneOf_Field13 + // *SampleOneOf_Field14 + // *SampleOneOf_Field15 + // *SampleOneOf_SubMessage + TestOneof isSampleOneOf_TestOneof `protobuf_oneof:"test_oneof"` +} + +func (m *SampleOneOf) Reset() { *m = SampleOneOf{} } +func (*SampleOneOf) ProtoMessage() {} + +type isSampleOneOf_TestOneof interface { + isSampleOneOf_TestOneof() + Equal(interface{}) bool + VerboseEqual(interface{}) error + MarshalTo([]byte) (int, error) + Size() int +} + +type SampleOneOf_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,proto3,oneof"` +} +type SampleOneOf_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,proto3,oneof"` +} +type SampleOneOf_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,proto3,oneof"` +} +type SampleOneOf_Field4 struct { + Field4 int64 `protobuf:"varint,4,opt,name=Field4,proto3,oneof"` +} +type SampleOneOf_Field5 struct { + Field5 uint32 `protobuf:"varint,5,opt,name=Field5,proto3,oneof"` +} +type SampleOneOf_Field6 struct { + Field6 uint64 `protobuf:"varint,6,opt,name=Field6,proto3,oneof"` +} +type SampleOneOf_Field7 struct { + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7,proto3,oneof"` +} +type SampleOneOf_Field8 struct { + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8,proto3,oneof"` +} +type SampleOneOf_Field9 struct { + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9,proto3,oneof"` +} +type SampleOneOf_Field10 struct { + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10,proto3,oneof"` +} +type SampleOneOf_Field11 struct { + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11,proto3,oneof"` +} +type SampleOneOf_Field12 struct { + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12,proto3,oneof"` +} +type SampleOneOf_Field13 struct { + Field13 bool `protobuf:"varint,13,opt,name=Field13,proto3,oneof"` +} +type SampleOneOf_Field14 struct { + Field14 string `protobuf:"bytes,14,opt,name=Field14,proto3,oneof"` +} +type SampleOneOf_Field15 struct { + Field15 []byte `protobuf:"bytes,15,opt,name=Field15,proto3,oneof"` +} +type SampleOneOf_SubMessage struct { + SubMessage *Subby `protobuf:"bytes,16,opt,name=sub_message,oneof"` +} + +func (*SampleOneOf_Field1) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field2) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field3) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field4) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field5) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field6) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field7) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field8) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field9) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field10) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field11) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field12) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field13) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field14) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field15) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_SubMessage) isSampleOneOf_TestOneof() {} + +func (m *SampleOneOf) GetTestOneof() isSampleOneOf_TestOneof { + if m != nil { + return m.TestOneof + } + return nil +} + +func (m *SampleOneOf) GetField1() float64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *SampleOneOf) GetField2() float32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *SampleOneOf) GetField3() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *SampleOneOf) GetField4() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field4); ok { + return x.Field4 + } + return 0 +} + +func (m *SampleOneOf) GetField5() uint32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field5); ok { + return x.Field5 + } + return 0 +} + +func (m *SampleOneOf) GetField6() uint64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field6); ok { + return x.Field6 + } + return 0 +} + +func (m *SampleOneOf) GetField7() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field7); ok { + return x.Field7 + } + return 0 +} + +func (m *SampleOneOf) GetField8() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field8); ok { + return x.Field8 + } + return 0 +} + +func (m *SampleOneOf) GetField9() uint32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field9); ok { + return x.Field9 + } + return 0 +} + +func (m *SampleOneOf) GetField10() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field10); ok { + return x.Field10 + } + return 0 +} + +func (m *SampleOneOf) GetField11() uint64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field11); ok { + return x.Field11 + } + return 0 +} + +func (m *SampleOneOf) GetField12() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field12); ok { + return x.Field12 + } + return 0 +} + +func (m *SampleOneOf) GetField13() bool { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field13); ok { + return x.Field13 + } + return false +} + +func (m *SampleOneOf) GetField14() string { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field14); ok { + return x.Field14 + } + return "" +} + +func (m *SampleOneOf) GetField15() []byte { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field15); ok { + return x.Field15 + } + return nil +} + +func (m *SampleOneOf) GetSubMessage() *Subby { + if x, ok := m.GetTestOneof().(*SampleOneOf_SubMessage); ok { + return x.SubMessage + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*SampleOneOf) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _SampleOneOf_OneofMarshaler, _SampleOneOf_OneofUnmarshaler, []interface{}{ + (*SampleOneOf_Field1)(nil), + (*SampleOneOf_Field2)(nil), + (*SampleOneOf_Field3)(nil), + (*SampleOneOf_Field4)(nil), + (*SampleOneOf_Field5)(nil), + (*SampleOneOf_Field6)(nil), + (*SampleOneOf_Field7)(nil), + (*SampleOneOf_Field8)(nil), + (*SampleOneOf_Field9)(nil), + (*SampleOneOf_Field10)(nil), + (*SampleOneOf_Field11)(nil), + (*SampleOneOf_Field12)(nil), + (*SampleOneOf_Field13)(nil), + (*SampleOneOf_Field14)(nil), + (*SampleOneOf_Field15)(nil), + (*SampleOneOf_SubMessage)(nil), + } +} + +func _SampleOneOf_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*SampleOneOf) + // test_oneof + switch x := m.TestOneof.(type) { + case *SampleOneOf_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *SampleOneOf_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *SampleOneOf_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case *SampleOneOf_Field4: + _ = b.EncodeVarint(4<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field4)) + case *SampleOneOf_Field5: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field5)) + case *SampleOneOf_Field6: + _ = b.EncodeVarint(6<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field6)) + case *SampleOneOf_Field7: + _ = b.EncodeVarint(7<<3 | proto.WireVarint) + _ = b.EncodeZigzag32(uint64(x.Field7)) + case *SampleOneOf_Field8: + _ = b.EncodeVarint(8<<3 | proto.WireVarint) + _ = b.EncodeZigzag64(uint64(x.Field8)) + case *SampleOneOf_Field9: + _ = b.EncodeVarint(9<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field9)) + case *SampleOneOf_Field10: + _ = b.EncodeVarint(10<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field10)) + case *SampleOneOf_Field11: + _ = b.EncodeVarint(11<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field11)) + case *SampleOneOf_Field12: + _ = b.EncodeVarint(12<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field12)) + case *SampleOneOf_Field13: + t := uint64(0) + if x.Field13 { + t = 1 + } + _ = b.EncodeVarint(13<<3 | proto.WireVarint) + _ = b.EncodeVarint(t) + case *SampleOneOf_Field14: + _ = b.EncodeVarint(14<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field14) + case *SampleOneOf_Field15: + _ = b.EncodeVarint(15<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field15) + case *SampleOneOf_SubMessage: + _ = b.EncodeVarint(16<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("SampleOneOf.TestOneof has unexpected type %T", x) + } + return nil +} + +func _SampleOneOf_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*SampleOneOf) + switch tag { + case 1: // test_oneof.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field1{math.Float64frombits(x)} + return true, err + case 2: // test_oneof.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // test_oneof.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field3{int32(x)} + return true, err + case 4: // test_oneof.Field4 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field4{int64(x)} + return true, err + case 5: // test_oneof.Field5 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field5{uint32(x)} + return true, err + case 6: // test_oneof.Field6 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field6{x} + return true, err + case 7: // test_oneof.Field7 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag32() + m.TestOneof = &SampleOneOf_Field7{int32(x)} + return true, err + case 8: // test_oneof.Field8 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag64() + m.TestOneof = &SampleOneOf_Field8{int64(x)} + return true, err + case 9: // test_oneof.Field9 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field9{uint32(x)} + return true, err + case 10: // test_oneof.Field10 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field10{int32(x)} + return true, err + case 11: // test_oneof.Field11 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field11{x} + return true, err + case 12: // test_oneof.Field12 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field12{int64(x)} + return true, err + case 13: // test_oneof.Field13 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field13{x != 0} + return true, err + case 14: // test_oneof.Field14 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.TestOneof = &SampleOneOf_Field14{x} + return true, err + case 15: // test_oneof.Field15 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.TestOneof = &SampleOneOf_Field15{x} + return true, err + case 16: // test_oneof.sub_message + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.TestOneof = &SampleOneOf_SubMessage{msg} + return true, err + default: + return false, nil + } +} + +func (this *Subby) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *SampleOneOf) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func OneDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unsafemarshaler/one.proto"), + Package: func(v string) *string { return &v }("one"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Subby"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("sub"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("SampleOneOf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("sub_message"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(0), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("test_oneof")}}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x1}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + Syntax: func(v string) *string { return &v }("proto3"), + }}, + } +} +func (this *Subby) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Subby) + if !ok { + return fmt.Errorf("that is not of type *Subby") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Subby but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Subbybut is not nil && this == nil") + } + if this.Sub != that1.Sub { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) + } + return nil +} +func (this *Subby) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Subby) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Sub != that1.Sub { + return false + } + return true +} +func (this *SampleOneOf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOfbut is not nil && this == nil") + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return fmt.Errorf("this.TestOneof != nil && that1.TestOneof == nil") + } + } else if this.TestOneof == nil { + return fmt.Errorf("this.TestOneof == nil && that1.TestOneof != nil") + } else if err := this.TestOneof.VerboseEqual(that1.TestOneof); err != nil { + return err + } + return nil +} +func (this *SampleOneOf_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field1) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *SampleOneOf_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field2) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *SampleOneOf_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field3) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *SampleOneOf_Field4) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field4) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field4") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field4 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field4but is not nil && this == nil") + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + return nil +} +func (this *SampleOneOf_Field5) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field5) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field5") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field5 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field5but is not nil && this == nil") + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + return nil +} +func (this *SampleOneOf_Field6) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field6) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field6") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field6 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field6but is not nil && this == nil") + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + return nil +} +func (this *SampleOneOf_Field7) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field7) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field7") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field7 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field7but is not nil && this == nil") + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + return nil +} +func (this *SampleOneOf_Field8) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field8) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field8") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field8 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field8but is not nil && this == nil") + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + return nil +} +func (this *SampleOneOf_Field9) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field9) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field9") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field9 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field9but is not nil && this == nil") + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + return nil +} +func (this *SampleOneOf_Field10) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field10) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field10") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field10 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field10but is not nil && this == nil") + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + return nil +} +func (this *SampleOneOf_Field11) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field11) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field11") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field11 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field11but is not nil && this == nil") + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + return nil +} +func (this *SampleOneOf_Field12) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field12) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field12") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field12 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field12but is not nil && this == nil") + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + return nil +} +func (this *SampleOneOf_Field13) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field13) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field13") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field13 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field13but is not nil && this == nil") + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + return nil +} +func (this *SampleOneOf_Field14) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field14) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field14") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field14 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field14but is not nil && this == nil") + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + return nil +} +func (this *SampleOneOf_Field15) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field15) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field15") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field15 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field15but is not nil && this == nil") + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + return nil +} +func (this *SampleOneOf_SubMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_SubMessage) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_SubMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_SubMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_SubMessagebut is not nil && this == nil") + } + if !this.SubMessage.Equal(that1.SubMessage) { + return fmt.Errorf("SubMessage this(%v) Not Equal that(%v)", this.SubMessage, that1.SubMessage) + } + return nil +} +func (this *SampleOneOf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return false + } + } else if this.TestOneof == nil { + return false + } else if !this.TestOneof.Equal(that1.TestOneof) { + return false + } + return true +} +func (this *SampleOneOf_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *SampleOneOf_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *SampleOneOf_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *SampleOneOf_Field4) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field4) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field4 != that1.Field4 { + return false + } + return true +} +func (this *SampleOneOf_Field5) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field5) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field5 != that1.Field5 { + return false + } + return true +} +func (this *SampleOneOf_Field6) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field6) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field6 != that1.Field6 { + return false + } + return true +} +func (this *SampleOneOf_Field7) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field7) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field7 != that1.Field7 { + return false + } + return true +} +func (this *SampleOneOf_Field8) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field8) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field8 != that1.Field8 { + return false + } + return true +} +func (this *SampleOneOf_Field9) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field9) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field9 != that1.Field9 { + return false + } + return true +} +func (this *SampleOneOf_Field10) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field10) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field10 != that1.Field10 { + return false + } + return true +} +func (this *SampleOneOf_Field11) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field11) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field11 != that1.Field11 { + return false + } + return true +} +func (this *SampleOneOf_Field12) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field12) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field12 != that1.Field12 { + return false + } + return true +} +func (this *SampleOneOf_Field13) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field13) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field13 != that1.Field13 { + return false + } + return true +} +func (this *SampleOneOf_Field14) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field14) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field14 != that1.Field14 { + return false + } + return true +} +func (this *SampleOneOf_Field15) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field15) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + return true +} +func (this *SampleOneOf_SubMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_SubMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage.Equal(that1.SubMessage) { + return false + } + return true +} +func (this *Subby) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&one.Subby{") + s = append(s, "Sub: "+fmt.Sprintf("%#v", this.Sub)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SampleOneOf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 20) + s = append(s, "&one.SampleOneOf{") + if this.TestOneof != nil { + s = append(s, "TestOneof: "+fmt.Sprintf("%#v", this.TestOneof)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SampleOneOf_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field4) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field4{` + + `Field4:` + fmt.Sprintf("%#v", this.Field4) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field5) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field5{` + + `Field5:` + fmt.Sprintf("%#v", this.Field5) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field6) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field6{` + + `Field6:` + fmt.Sprintf("%#v", this.Field6) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field7) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field7{` + + `Field7:` + fmt.Sprintf("%#v", this.Field7) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field8) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field8{` + + `Field8:` + fmt.Sprintf("%#v", this.Field8) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field9) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field9{` + + `Field9:` + fmt.Sprintf("%#v", this.Field9) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field10) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field10{` + + `Field10:` + fmt.Sprintf("%#v", this.Field10) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field11) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field11{` + + `Field11:` + fmt.Sprintf("%#v", this.Field11) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field12) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field12{` + + `Field12:` + fmt.Sprintf("%#v", this.Field12) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field13) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field13{` + + `Field13:` + fmt.Sprintf("%#v", this.Field13) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field14) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field14{` + + `Field14:` + fmt.Sprintf("%#v", this.Field14) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field15) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field15{` + + `Field15:` + fmt.Sprintf("%#v", this.Field15) + `}`}, ", ") + return s +} +func (this *SampleOneOf_SubMessage) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_SubMessage{` + + `SubMessage:` + fmt.Sprintf("%#v", this.SubMessage) + `}`}, ", ") + return s +} +func valueToGoStringOne(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringOne(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedSubby(r randyOne, easy bool) *Subby { + this := &Subby{} + this.Sub = randStringOne(r) + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedSampleOneOf(r randyOne, easy bool) *SampleOneOf { + this := &SampleOneOf{} + oneofNumber_TestOneof := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}[r.Intn(16)] + switch oneofNumber_TestOneof { + case 1: + this.TestOneof = NewPopulatedSampleOneOf_Field1(r, easy) + case 2: + this.TestOneof = NewPopulatedSampleOneOf_Field2(r, easy) + case 3: + this.TestOneof = NewPopulatedSampleOneOf_Field3(r, easy) + case 4: + this.TestOneof = NewPopulatedSampleOneOf_Field4(r, easy) + case 5: + this.TestOneof = NewPopulatedSampleOneOf_Field5(r, easy) + case 6: + this.TestOneof = NewPopulatedSampleOneOf_Field6(r, easy) + case 7: + this.TestOneof = NewPopulatedSampleOneOf_Field7(r, easy) + case 8: + this.TestOneof = NewPopulatedSampleOneOf_Field8(r, easy) + case 9: + this.TestOneof = NewPopulatedSampleOneOf_Field9(r, easy) + case 10: + this.TestOneof = NewPopulatedSampleOneOf_Field10(r, easy) + case 11: + this.TestOneof = NewPopulatedSampleOneOf_Field11(r, easy) + case 12: + this.TestOneof = NewPopulatedSampleOneOf_Field12(r, easy) + case 13: + this.TestOneof = NewPopulatedSampleOneOf_Field13(r, easy) + case 14: + this.TestOneof = NewPopulatedSampleOneOf_Field14(r, easy) + case 15: + this.TestOneof = NewPopulatedSampleOneOf_Field15(r, easy) + case 16: + this.TestOneof = NewPopulatedSampleOneOf_SubMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedSampleOneOf_Field1(r randyOne, easy bool) *SampleOneOf_Field1 { + this := &SampleOneOf_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field2(r randyOne, easy bool) *SampleOneOf_Field2 { + this := &SampleOneOf_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field3(r randyOne, easy bool) *SampleOneOf_Field3 { + this := &SampleOneOf_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field4(r randyOne, easy bool) *SampleOneOf_Field4 { + this := &SampleOneOf_Field4{} + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field5(r randyOne, easy bool) *SampleOneOf_Field5 { + this := &SampleOneOf_Field5{} + this.Field5 = uint32(r.Uint32()) + return this +} +func NewPopulatedSampleOneOf_Field6(r randyOne, easy bool) *SampleOneOf_Field6 { + this := &SampleOneOf_Field6{} + this.Field6 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedSampleOneOf_Field7(r randyOne, easy bool) *SampleOneOf_Field7 { + this := &SampleOneOf_Field7{} + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field8(r randyOne, easy bool) *SampleOneOf_Field8 { + this := &SampleOneOf_Field8{} + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field9(r randyOne, easy bool) *SampleOneOf_Field9 { + this := &SampleOneOf_Field9{} + this.Field9 = uint32(r.Uint32()) + return this +} +func NewPopulatedSampleOneOf_Field10(r randyOne, easy bool) *SampleOneOf_Field10 { + this := &SampleOneOf_Field10{} + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field11(r randyOne, easy bool) *SampleOneOf_Field11 { + this := &SampleOneOf_Field11{} + this.Field11 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedSampleOneOf_Field12(r randyOne, easy bool) *SampleOneOf_Field12 { + this := &SampleOneOf_Field12{} + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field13(r randyOne, easy bool) *SampleOneOf_Field13 { + this := &SampleOneOf_Field13{} + this.Field13 = bool(bool(r.Intn(2) == 0)) + return this +} +func NewPopulatedSampleOneOf_Field14(r randyOne, easy bool) *SampleOneOf_Field14 { + this := &SampleOneOf_Field14{} + this.Field14 = randStringOne(r) + return this +} +func NewPopulatedSampleOneOf_Field15(r randyOne, easy bool) *SampleOneOf_Field15 { + this := &SampleOneOf_Field15{} + v1 := r.Intn(100) + this.Field15 = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedSampleOneOf_SubMessage(r randyOne, easy bool) *SampleOneOf_SubMessage { + this := &SampleOneOf_SubMessage{} + this.SubMessage = NewPopulatedSubby(r, easy) + return this +} + +type randyOne interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneOne(r randyOne) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringOne(r randyOne) string { + v2 := r.Intn(100) + tmps := make([]rune, v2) + for i := 0; i < v2; i++ { + tmps[i] = randUTF8RuneOne(r) + } + return string(tmps) +} +func randUnrecognizedOne(r randyOne, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldOne(data, r, fieldNumber, wire) + } + return data +} +func randFieldOne(data []byte, r randyOne, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateOne(data, uint64(key)) + v3 := r.Int63() + if r.Intn(2) == 0 { + v3 *= -1 + } + data = encodeVarintPopulateOne(data, uint64(v3)) + case 1: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateOne(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateOne(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateOne(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Subby) Size() (n int) { + var l int + _ = l + l = len(m.Sub) + if l > 0 { + n += 1 + l + sovOne(uint64(l)) + } + return n +} + +func (m *SampleOneOf) Size() (n int) { + var l int + _ = l + if m.TestOneof != nil { + n += m.TestOneof.Size() + } + return n +} + +func (m *SampleOneOf_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *SampleOneOf_Field4) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field4)) + return n +} +func (m *SampleOneOf_Field5) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field5)) + return n +} +func (m *SampleOneOf_Field6) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field6)) + return n +} +func (m *SampleOneOf_Field7) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field7)) + return n +} +func (m *SampleOneOf_Field8) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field8)) + return n +} +func (m *SampleOneOf_Field9) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field10) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field11) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field12) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field13) Size() (n int) { + var l int + _ = l + n += 2 + return n +} +func (m *SampleOneOf_Field14) Size() (n int) { + var l int + _ = l + l = len(m.Field14) + n += 1 + l + sovOne(uint64(l)) + return n +} +func (m *SampleOneOf_Field15) Size() (n int) { + var l int + _ = l + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovOne(uint64(l)) + } + return n +} +func (m *SampleOneOf_SubMessage) Size() (n int) { + var l int + _ = l + if m.SubMessage != nil { + l = m.SubMessage.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} + +func sovOne(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozOne(x uint64) (n int) { + return sovOne(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Subby) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Subby{`, + `Sub:` + fmt.Sprintf("%v", this.Sub) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf{`, + `TestOneof:` + fmt.Sprintf("%v", this.TestOneof) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field4) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field4{`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field5) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field5{`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field6) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field6{`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field7) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field7{`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field8) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field8{`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field9) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field9{`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field10) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field10{`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field11) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field11{`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field12) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field12{`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field13) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field13{`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field14) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field14{`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field15) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field15{`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_SubMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_SubMessage{`, + `SubMessage:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func valueToStringOne(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Subby) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Subby) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Sub) > 0 { + data[i] = 0xa + i++ + i = encodeVarintOne(data, i, uint64(len(m.Sub))) + i += copy(data[i:], m.Sub) + } + return i, nil +} + +func (m *SampleOneOf) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *SampleOneOf) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.TestOneof != nil { + nn1, err := m.TestOneof.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += nn1 + } + return i, nil +} + +func (m *SampleOneOf_Field1) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = m.Field1 + i += 8 + return i, nil +} +func (m *SampleOneOf_Field2) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x15 + i++ + *(*float32)(unsafe.Pointer(&data[i])) = m.Field2 + i += 4 + return i, nil +} +func (m *SampleOneOf_Field3) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x18 + i++ + i = encodeVarintOne(data, i, uint64(m.Field3)) + return i, nil +} +func (m *SampleOneOf_Field4) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x20 + i++ + i = encodeVarintOne(data, i, uint64(m.Field4)) + return i, nil +} +func (m *SampleOneOf_Field5) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x28 + i++ + i = encodeVarintOne(data, i, uint64(m.Field5)) + return i, nil +} +func (m *SampleOneOf_Field6) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x30 + i++ + i = encodeVarintOne(data, i, uint64(m.Field6)) + return i, nil +} +func (m *SampleOneOf_Field7) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x38 + i++ + i = encodeVarintOne(data, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31)))) + return i, nil +} +func (m *SampleOneOf_Field8) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x40 + i++ + i = encodeVarintOne(data, i, uint64((uint64(m.Field8)<<1)^uint64((m.Field8>>63)))) + return i, nil +} +func (m *SampleOneOf_Field9) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x4d + i++ + *(*uint32)(unsafe.Pointer(&data[i])) = m.Field9 + i += 4 + return i, nil +} +func (m *SampleOneOf_Field10) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x55 + i++ + *(*int32)(unsafe.Pointer(&data[i])) = m.Field10 + i += 4 + return i, nil +} +func (m *SampleOneOf_Field11) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x59 + i++ + *(*uint64)(unsafe.Pointer(&data[i])) = m.Field11 + i += 8 + return i, nil +} +func (m *SampleOneOf_Field12) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x61 + i++ + *(*int64)(unsafe.Pointer(&data[i])) = m.Field12 + i += 8 + return i, nil +} +func (m *SampleOneOf_Field13) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x68 + i++ + if m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + return i, nil +} +func (m *SampleOneOf_Field14) MarshalTo(data []byte) (int, error) { + i := 0 + data[i] = 0x72 + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field14))) + i += copy(data[i:], m.Field14) + return i, nil +} +func (m *SampleOneOf_Field15) MarshalTo(data []byte) (int, error) { + i := 0 + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintOne(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + return i, nil +} +func (m *SampleOneOf_SubMessage) MarshalTo(data []byte) (int, error) { + i := 0 + if m.SubMessage != nil { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + i = encodeVarintOne(data, i, uint64(m.SubMessage.Size())) + n2, err := m.SubMessage.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + } + return i, nil +} +func encodeFixed64One(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32One(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintOne(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafemarshaler/one.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafemarshaler/one.proto new file mode 100644 index 0000000000000000000000000000000000000000..2cc11418126ce6d1dc38547657579014169784b6 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafemarshaler/one.proto @@ -0,0 +1,80 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 one; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = true; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Subby { + string sub = 1; +} + +message SampleOneOf { + oneof test_oneof { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + int64 Field4 = 4; + uint32 Field5 = 5; + uint64 Field6 = 6; + sint32 Field7 = 7; + sint64 Field8 = 8; + fixed32 Field9 = 9; + sfixed32 Field10 = 10; + fixed64 Field11 = 11; + sfixed64 Field12 = 12; + bool Field13 = 13; + string Field14 = 14; + bytes Field15 = 15; + Subby sub_message = 16; + } +} + + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafemarshaler/onepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafemarshaler/onepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..2a282dfd01222d1ec0742efc1311b462663e1d82 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafemarshaler/onepb_test.go @@ -0,0 +1,390 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafemarshaler/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/unsafemarshaler/one.proto + +It has these top-level messages: + Subby + SampleOneOf +*/ +package one + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestSubbyProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSubbyMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSampleOneOfMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSampleOneOfJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSubbyProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOneDescription(t *testing.T) { + OneDescription() +} +func TestSubbyVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSampleOneOfVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSubbyGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSampleOneOfGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSubbySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSampleOneOfSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSubbyStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestSampleOneOfStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeunmarshaler/one.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeunmarshaler/one.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..db02932f06a5425d4ac9d286e6dcac769246475a --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeunmarshaler/one.pb.go @@ -0,0 +1,4257 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeunmarshaler/one.proto +// DO NOT EDIT! + +/* + Package one is a generated protocol buffer package. + + It is generated from these files: + combos/unsafeunmarshaler/one.proto + + It has these top-level messages: + Subby + SampleOneOf +*/ +package one + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" +import unsafe "unsafe" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Subby struct { + Sub string `protobuf:"bytes,1,opt,name=sub,proto3" json:"sub,omitempty"` +} + +func (m *Subby) Reset() { *m = Subby{} } +func (*Subby) ProtoMessage() {} + +type SampleOneOf struct { + // Types that are valid to be assigned to TestOneof: + // *SampleOneOf_Field1 + // *SampleOneOf_Field2 + // *SampleOneOf_Field3 + // *SampleOneOf_Field4 + // *SampleOneOf_Field5 + // *SampleOneOf_Field6 + // *SampleOneOf_Field7 + // *SampleOneOf_Field8 + // *SampleOneOf_Field9 + // *SampleOneOf_Field10 + // *SampleOneOf_Field11 + // *SampleOneOf_Field12 + // *SampleOneOf_Field13 + // *SampleOneOf_Field14 + // *SampleOneOf_Field15 + // *SampleOneOf_SubMessage + TestOneof isSampleOneOf_TestOneof `protobuf_oneof:"test_oneof"` +} + +func (m *SampleOneOf) Reset() { *m = SampleOneOf{} } +func (*SampleOneOf) ProtoMessage() {} + +type isSampleOneOf_TestOneof interface { + isSampleOneOf_TestOneof() + Equal(interface{}) bool + VerboseEqual(interface{}) error + Size() int +} + +type SampleOneOf_Field1 struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1,proto3,oneof"` +} +type SampleOneOf_Field2 struct { + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2,proto3,oneof"` +} +type SampleOneOf_Field3 struct { + Field3 int32 `protobuf:"varint,3,opt,name=Field3,proto3,oneof"` +} +type SampleOneOf_Field4 struct { + Field4 int64 `protobuf:"varint,4,opt,name=Field4,proto3,oneof"` +} +type SampleOneOf_Field5 struct { + Field5 uint32 `protobuf:"varint,5,opt,name=Field5,proto3,oneof"` +} +type SampleOneOf_Field6 struct { + Field6 uint64 `protobuf:"varint,6,opt,name=Field6,proto3,oneof"` +} +type SampleOneOf_Field7 struct { + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7,proto3,oneof"` +} +type SampleOneOf_Field8 struct { + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8,proto3,oneof"` +} +type SampleOneOf_Field9 struct { + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9,proto3,oneof"` +} +type SampleOneOf_Field10 struct { + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10,proto3,oneof"` +} +type SampleOneOf_Field11 struct { + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11,proto3,oneof"` +} +type SampleOneOf_Field12 struct { + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12,proto3,oneof"` +} +type SampleOneOf_Field13 struct { + Field13 bool `protobuf:"varint,13,opt,name=Field13,proto3,oneof"` +} +type SampleOneOf_Field14 struct { + Field14 string `protobuf:"bytes,14,opt,name=Field14,proto3,oneof"` +} +type SampleOneOf_Field15 struct { + Field15 []byte `protobuf:"bytes,15,opt,name=Field15,proto3,oneof"` +} +type SampleOneOf_SubMessage struct { + SubMessage *Subby `protobuf:"bytes,16,opt,name=sub_message,oneof"` +} + +func (*SampleOneOf_Field1) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field2) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field3) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field4) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field5) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field6) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field7) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field8) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field9) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field10) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field11) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field12) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field13) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field14) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_Field15) isSampleOneOf_TestOneof() {} +func (*SampleOneOf_SubMessage) isSampleOneOf_TestOneof() {} + +func (m *SampleOneOf) GetTestOneof() isSampleOneOf_TestOneof { + if m != nil { + return m.TestOneof + } + return nil +} + +func (m *SampleOneOf) GetField1() float64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field1); ok { + return x.Field1 + } + return 0 +} + +func (m *SampleOneOf) GetField2() float32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field2); ok { + return x.Field2 + } + return 0 +} + +func (m *SampleOneOf) GetField3() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field3); ok { + return x.Field3 + } + return 0 +} + +func (m *SampleOneOf) GetField4() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field4); ok { + return x.Field4 + } + return 0 +} + +func (m *SampleOneOf) GetField5() uint32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field5); ok { + return x.Field5 + } + return 0 +} + +func (m *SampleOneOf) GetField6() uint64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field6); ok { + return x.Field6 + } + return 0 +} + +func (m *SampleOneOf) GetField7() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field7); ok { + return x.Field7 + } + return 0 +} + +func (m *SampleOneOf) GetField8() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field8); ok { + return x.Field8 + } + return 0 +} + +func (m *SampleOneOf) GetField9() uint32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field9); ok { + return x.Field9 + } + return 0 +} + +func (m *SampleOneOf) GetField10() int32 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field10); ok { + return x.Field10 + } + return 0 +} + +func (m *SampleOneOf) GetField11() uint64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field11); ok { + return x.Field11 + } + return 0 +} + +func (m *SampleOneOf) GetField12() int64 { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field12); ok { + return x.Field12 + } + return 0 +} + +func (m *SampleOneOf) GetField13() bool { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field13); ok { + return x.Field13 + } + return false +} + +func (m *SampleOneOf) GetField14() string { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field14); ok { + return x.Field14 + } + return "" +} + +func (m *SampleOneOf) GetField15() []byte { + if x, ok := m.GetTestOneof().(*SampleOneOf_Field15); ok { + return x.Field15 + } + return nil +} + +func (m *SampleOneOf) GetSubMessage() *Subby { + if x, ok := m.GetTestOneof().(*SampleOneOf_SubMessage); ok { + return x.SubMessage + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*SampleOneOf) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), []interface{}) { + return _SampleOneOf_OneofMarshaler, _SampleOneOf_OneofUnmarshaler, []interface{}{ + (*SampleOneOf_Field1)(nil), + (*SampleOneOf_Field2)(nil), + (*SampleOneOf_Field3)(nil), + (*SampleOneOf_Field4)(nil), + (*SampleOneOf_Field5)(nil), + (*SampleOneOf_Field6)(nil), + (*SampleOneOf_Field7)(nil), + (*SampleOneOf_Field8)(nil), + (*SampleOneOf_Field9)(nil), + (*SampleOneOf_Field10)(nil), + (*SampleOneOf_Field11)(nil), + (*SampleOneOf_Field12)(nil), + (*SampleOneOf_Field13)(nil), + (*SampleOneOf_Field14)(nil), + (*SampleOneOf_Field15)(nil), + (*SampleOneOf_SubMessage)(nil), + } +} + +func _SampleOneOf_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*SampleOneOf) + // test_oneof + switch x := m.TestOneof.(type) { + case *SampleOneOf_Field1: + _ = b.EncodeVarint(1<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(math.Float64bits(x.Field1)) + case *SampleOneOf_Field2: + _ = b.EncodeVarint(2<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(math.Float32bits(x.Field2))) + case *SampleOneOf_Field3: + _ = b.EncodeVarint(3<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field3)) + case *SampleOneOf_Field4: + _ = b.EncodeVarint(4<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field4)) + case *SampleOneOf_Field5: + _ = b.EncodeVarint(5<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field5)) + case *SampleOneOf_Field6: + _ = b.EncodeVarint(6<<3 | proto.WireVarint) + _ = b.EncodeVarint(uint64(x.Field6)) + case *SampleOneOf_Field7: + _ = b.EncodeVarint(7<<3 | proto.WireVarint) + _ = b.EncodeZigzag32(uint64(x.Field7)) + case *SampleOneOf_Field8: + _ = b.EncodeVarint(8<<3 | proto.WireVarint) + _ = b.EncodeZigzag64(uint64(x.Field8)) + case *SampleOneOf_Field9: + _ = b.EncodeVarint(9<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field9)) + case *SampleOneOf_Field10: + _ = b.EncodeVarint(10<<3 | proto.WireFixed32) + _ = b.EncodeFixed32(uint64(x.Field10)) + case *SampleOneOf_Field11: + _ = b.EncodeVarint(11<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field11)) + case *SampleOneOf_Field12: + _ = b.EncodeVarint(12<<3 | proto.WireFixed64) + _ = b.EncodeFixed64(uint64(x.Field12)) + case *SampleOneOf_Field13: + t := uint64(0) + if x.Field13 { + t = 1 + } + _ = b.EncodeVarint(13<<3 | proto.WireVarint) + _ = b.EncodeVarint(t) + case *SampleOneOf_Field14: + _ = b.EncodeVarint(14<<3 | proto.WireBytes) + _ = b.EncodeStringBytes(x.Field14) + case *SampleOneOf_Field15: + _ = b.EncodeVarint(15<<3 | proto.WireBytes) + _ = b.EncodeRawBytes(x.Field15) + case *SampleOneOf_SubMessage: + _ = b.EncodeVarint(16<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.SubMessage); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("SampleOneOf.TestOneof has unexpected type %T", x) + } + return nil +} + +func _SampleOneOf_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*SampleOneOf) + switch tag { + case 1: // test_oneof.Field1 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field1{math.Float64frombits(x)} + return true, err + case 2: // test_oneof.Field2 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field2{math.Float32frombits(uint32(x))} + return true, err + case 3: // test_oneof.Field3 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field3{int32(x)} + return true, err + case 4: // test_oneof.Field4 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field4{int64(x)} + return true, err + case 5: // test_oneof.Field5 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field5{uint32(x)} + return true, err + case 6: // test_oneof.Field6 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field6{x} + return true, err + case 7: // test_oneof.Field7 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag32() + m.TestOneof = &SampleOneOf_Field7{int32(x)} + return true, err + case 8: // test_oneof.Field8 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeZigzag64() + m.TestOneof = &SampleOneOf_Field8{int64(x)} + return true, err + case 9: // test_oneof.Field9 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field9{uint32(x)} + return true, err + case 10: // test_oneof.Field10 + if wire != proto.WireFixed32 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed32() + m.TestOneof = &SampleOneOf_Field10{int32(x)} + return true, err + case 11: // test_oneof.Field11 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field11{x} + return true, err + case 12: // test_oneof.Field12 + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.TestOneof = &SampleOneOf_Field12{int64(x)} + return true, err + case 13: // test_oneof.Field13 + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.TestOneof = &SampleOneOf_Field13{x != 0} + return true, err + case 14: // test_oneof.Field14 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.TestOneof = &SampleOneOf_Field14{x} + return true, err + case 15: // test_oneof.Field15 + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeRawBytes(true) + m.TestOneof = &SampleOneOf_Field15{x} + return true, err + case 16: // test_oneof.sub_message + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Subby) + err := b.DecodeMessage(msg) + m.TestOneof = &SampleOneOf_SubMessage{msg} + return true, err + default: + return false, nil + } +} + +func (this *Subby) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func (this *SampleOneOf) Description() (desc *google_protobuf.FileDescriptorSet) { + return OneDescription() +} +func OneDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("combos/unsafeunmarshaler/one.proto"), + Package: func(v string) *string { return &v }("one"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Subby"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("sub"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("SampleOneOf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + OneofIndex: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("sub_message"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".one.Subby"), + OneofIndex: func(v int32) *int32 { return &v }(0), + }}, + OneofDecl: []*google_protobuf.OneofDescriptorProto{{Name: func(v string) *string { return &v }("test_oneof")}}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x1})}}, + Syntax: func(v string) *string { return &v }("proto3"), + }}, + } +} +func (this *Subby) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Subby) + if !ok { + return fmt.Errorf("that is not of type *Subby") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Subby but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Subbybut is not nil && this == nil") + } + if this.Sub != that1.Sub { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) + } + return nil +} +func (this *Subby) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Subby) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Sub != that1.Sub { + return false + } + return true +} +func (this *SampleOneOf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOfbut is not nil && this == nil") + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return fmt.Errorf("this.TestOneof != nil && that1.TestOneof == nil") + } + } else if this.TestOneof == nil { + return fmt.Errorf("this.TestOneof == nil && that1.TestOneof != nil") + } else if err := this.TestOneof.VerboseEqual(that1.TestOneof); err != nil { + return err + } + return nil +} +func (this *SampleOneOf_Field1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field1) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field1but is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *SampleOneOf_Field2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field2) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field2but is not nil && this == nil") + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + return nil +} +func (this *SampleOneOf_Field3) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field3) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field3") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field3 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field3but is not nil && this == nil") + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *SampleOneOf_Field4) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field4) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field4") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field4 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field4but is not nil && this == nil") + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + return nil +} +func (this *SampleOneOf_Field5) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field5) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field5") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field5 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field5but is not nil && this == nil") + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + return nil +} +func (this *SampleOneOf_Field6) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field6) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field6") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field6 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field6but is not nil && this == nil") + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + return nil +} +func (this *SampleOneOf_Field7) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field7) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field7") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field7 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field7but is not nil && this == nil") + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + return nil +} +func (this *SampleOneOf_Field8) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field8) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field8") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field8 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field8but is not nil && this == nil") + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + return nil +} +func (this *SampleOneOf_Field9) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field9) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field9") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field9 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field9but is not nil && this == nil") + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + return nil +} +func (this *SampleOneOf_Field10) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field10) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field10") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field10 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field10but is not nil && this == nil") + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + return nil +} +func (this *SampleOneOf_Field11) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field11) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field11") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field11 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field11but is not nil && this == nil") + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + return nil +} +func (this *SampleOneOf_Field12) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field12) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field12") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field12 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field12but is not nil && this == nil") + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + return nil +} +func (this *SampleOneOf_Field13) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field13) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field13") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field13 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field13but is not nil && this == nil") + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + return nil +} +func (this *SampleOneOf_Field14) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field14) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field14") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field14 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field14but is not nil && this == nil") + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + return nil +} +func (this *SampleOneOf_Field15) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_Field15) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_Field15") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_Field15 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_Field15but is not nil && this == nil") + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + return nil +} +func (this *SampleOneOf_SubMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*SampleOneOf_SubMessage) + if !ok { + return fmt.Errorf("that is not of type *SampleOneOf_SubMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *SampleOneOf_SubMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *SampleOneOf_SubMessagebut is not nil && this == nil") + } + if !this.SubMessage.Equal(that1.SubMessage) { + return fmt.Errorf("SubMessage this(%v) Not Equal that(%v)", this.SubMessage, that1.SubMessage) + } + return nil +} +func (this *SampleOneOf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.TestOneof == nil { + if this.TestOneof != nil { + return false + } + } else if this.TestOneof == nil { + return false + } else if !this.TestOneof.Equal(that1.TestOneof) { + return false + } + return true +} +func (this *SampleOneOf_Field1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + return true +} +func (this *SampleOneOf_Field2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != that1.Field2 { + return false + } + return true +} +func (this *SampleOneOf_Field3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field3 != that1.Field3 { + return false + } + return true +} +func (this *SampleOneOf_Field4) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field4) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field4 != that1.Field4 { + return false + } + return true +} +func (this *SampleOneOf_Field5) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field5) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field5 != that1.Field5 { + return false + } + return true +} +func (this *SampleOneOf_Field6) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field6) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field6 != that1.Field6 { + return false + } + return true +} +func (this *SampleOneOf_Field7) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field7) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field7 != that1.Field7 { + return false + } + return true +} +func (this *SampleOneOf_Field8) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field8) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field8 != that1.Field8 { + return false + } + return true +} +func (this *SampleOneOf_Field9) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field9) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field9 != that1.Field9 { + return false + } + return true +} +func (this *SampleOneOf_Field10) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field10) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field10 != that1.Field10 { + return false + } + return true +} +func (this *SampleOneOf_Field11) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field11) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field11 != that1.Field11 { + return false + } + return true +} +func (this *SampleOneOf_Field12) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field12) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field12 != that1.Field12 { + return false + } + return true +} +func (this *SampleOneOf_Field13) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field13) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field13 != that1.Field13 { + return false + } + return true +} +func (this *SampleOneOf_Field14) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field14) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field14 != that1.Field14 { + return false + } + return true +} +func (this *SampleOneOf_Field15) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_Field15) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + return true +} +func (this *SampleOneOf_SubMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SampleOneOf_SubMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.SubMessage.Equal(that1.SubMessage) { + return false + } + return true +} +func (this *Subby) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&one.Subby{") + s = append(s, "Sub: "+fmt.Sprintf("%#v", this.Sub)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SampleOneOf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 20) + s = append(s, "&one.SampleOneOf{") + if this.TestOneof != nil { + s = append(s, "TestOneof: "+fmt.Sprintf("%#v", this.TestOneof)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *SampleOneOf_Field1) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field1{` + + `Field1:` + fmt.Sprintf("%#v", this.Field1) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field2) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field2{` + + `Field2:` + fmt.Sprintf("%#v", this.Field2) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field3) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field3{` + + `Field3:` + fmt.Sprintf("%#v", this.Field3) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field4) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field4{` + + `Field4:` + fmt.Sprintf("%#v", this.Field4) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field5) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field5{` + + `Field5:` + fmt.Sprintf("%#v", this.Field5) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field6) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field6{` + + `Field6:` + fmt.Sprintf("%#v", this.Field6) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field7) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field7{` + + `Field7:` + fmt.Sprintf("%#v", this.Field7) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field8) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field8{` + + `Field8:` + fmt.Sprintf("%#v", this.Field8) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field9) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field9{` + + `Field9:` + fmt.Sprintf("%#v", this.Field9) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field10) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field10{` + + `Field10:` + fmt.Sprintf("%#v", this.Field10) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field11) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field11{` + + `Field11:` + fmt.Sprintf("%#v", this.Field11) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field12) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field12{` + + `Field12:` + fmt.Sprintf("%#v", this.Field12) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field13) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field13{` + + `Field13:` + fmt.Sprintf("%#v", this.Field13) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field14) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field14{` + + `Field14:` + fmt.Sprintf("%#v", this.Field14) + `}`}, ", ") + return s +} +func (this *SampleOneOf_Field15) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_Field15{` + + `Field15:` + fmt.Sprintf("%#v", this.Field15) + `}`}, ", ") + return s +} +func (this *SampleOneOf_SubMessage) GoString() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&one.SampleOneOf_SubMessage{` + + `SubMessage:` + fmt.Sprintf("%#v", this.SubMessage) + `}`}, ", ") + return s +} +func valueToGoStringOne(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringOne(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedSubby(r randyOne, easy bool) *Subby { + this := &Subby{} + this.Sub = randStringOne(r) + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedSampleOneOf(r randyOne, easy bool) *SampleOneOf { + this := &SampleOneOf{} + oneofNumber_TestOneof := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}[r.Intn(16)] + switch oneofNumber_TestOneof { + case 1: + this.TestOneof = NewPopulatedSampleOneOf_Field1(r, easy) + case 2: + this.TestOneof = NewPopulatedSampleOneOf_Field2(r, easy) + case 3: + this.TestOneof = NewPopulatedSampleOneOf_Field3(r, easy) + case 4: + this.TestOneof = NewPopulatedSampleOneOf_Field4(r, easy) + case 5: + this.TestOneof = NewPopulatedSampleOneOf_Field5(r, easy) + case 6: + this.TestOneof = NewPopulatedSampleOneOf_Field6(r, easy) + case 7: + this.TestOneof = NewPopulatedSampleOneOf_Field7(r, easy) + case 8: + this.TestOneof = NewPopulatedSampleOneOf_Field8(r, easy) + case 9: + this.TestOneof = NewPopulatedSampleOneOf_Field9(r, easy) + case 10: + this.TestOneof = NewPopulatedSampleOneOf_Field10(r, easy) + case 11: + this.TestOneof = NewPopulatedSampleOneOf_Field11(r, easy) + case 12: + this.TestOneof = NewPopulatedSampleOneOf_Field12(r, easy) + case 13: + this.TestOneof = NewPopulatedSampleOneOf_Field13(r, easy) + case 14: + this.TestOneof = NewPopulatedSampleOneOf_Field14(r, easy) + case 15: + this.TestOneof = NewPopulatedSampleOneOf_Field15(r, easy) + case 16: + this.TestOneof = NewPopulatedSampleOneOf_SubMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedSampleOneOf_Field1(r randyOne, easy bool) *SampleOneOf_Field1 { + this := &SampleOneOf_Field1{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field2(r randyOne, easy bool) *SampleOneOf_Field2 { + this := &SampleOneOf_Field2{} + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field3(r randyOne, easy bool) *SampleOneOf_Field3 { + this := &SampleOneOf_Field3{} + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field4(r randyOne, easy bool) *SampleOneOf_Field4 { + this := &SampleOneOf_Field4{} + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field5(r randyOne, easy bool) *SampleOneOf_Field5 { + this := &SampleOneOf_Field5{} + this.Field5 = uint32(r.Uint32()) + return this +} +func NewPopulatedSampleOneOf_Field6(r randyOne, easy bool) *SampleOneOf_Field6 { + this := &SampleOneOf_Field6{} + this.Field6 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedSampleOneOf_Field7(r randyOne, easy bool) *SampleOneOf_Field7 { + this := &SampleOneOf_Field7{} + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field8(r randyOne, easy bool) *SampleOneOf_Field8 { + this := &SampleOneOf_Field8{} + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field9(r randyOne, easy bool) *SampleOneOf_Field9 { + this := &SampleOneOf_Field9{} + this.Field9 = uint32(r.Uint32()) + return this +} +func NewPopulatedSampleOneOf_Field10(r randyOne, easy bool) *SampleOneOf_Field10 { + this := &SampleOneOf_Field10{} + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field11(r randyOne, easy bool) *SampleOneOf_Field11 { + this := &SampleOneOf_Field11{} + this.Field11 = uint64(uint64(r.Uint32())) + return this +} +func NewPopulatedSampleOneOf_Field12(r randyOne, easy bool) *SampleOneOf_Field12 { + this := &SampleOneOf_Field12{} + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + return this +} +func NewPopulatedSampleOneOf_Field13(r randyOne, easy bool) *SampleOneOf_Field13 { + this := &SampleOneOf_Field13{} + this.Field13 = bool(bool(r.Intn(2) == 0)) + return this +} +func NewPopulatedSampleOneOf_Field14(r randyOne, easy bool) *SampleOneOf_Field14 { + this := &SampleOneOf_Field14{} + this.Field14 = randStringOne(r) + return this +} +func NewPopulatedSampleOneOf_Field15(r randyOne, easy bool) *SampleOneOf_Field15 { + this := &SampleOneOf_Field15{} + v1 := r.Intn(100) + this.Field15 = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + return this +} +func NewPopulatedSampleOneOf_SubMessage(r randyOne, easy bool) *SampleOneOf_SubMessage { + this := &SampleOneOf_SubMessage{} + this.SubMessage = NewPopulatedSubby(r, easy) + return this +} + +type randyOne interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneOne(r randyOne) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringOne(r randyOne) string { + v2 := r.Intn(100) + tmps := make([]rune, v2) + for i := 0; i < v2; i++ { + tmps[i] = randUTF8RuneOne(r) + } + return string(tmps) +} +func randUnrecognizedOne(r randyOne, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldOne(data, r, fieldNumber, wire) + } + return data +} +func randFieldOne(data []byte, r randyOne, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateOne(data, uint64(key)) + v3 := r.Int63() + if r.Intn(2) == 0 { + v3 *= -1 + } + data = encodeVarintPopulateOne(data, uint64(v3)) + case 1: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateOne(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateOne(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateOne(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateOne(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Subby) Size() (n int) { + var l int + _ = l + l = len(m.Sub) + if l > 0 { + n += 1 + l + sovOne(uint64(l)) + } + return n +} + +func (m *SampleOneOf) Size() (n int) { + var l int + _ = l + if m.TestOneof != nil { + n += m.TestOneof.Size() + } + return n +} + +func (m *SampleOneOf_Field1) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field2) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field3) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field3)) + return n +} +func (m *SampleOneOf_Field4) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field4)) + return n +} +func (m *SampleOneOf_Field5) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field5)) + return n +} +func (m *SampleOneOf_Field6) Size() (n int) { + var l int + _ = l + n += 1 + sovOne(uint64(m.Field6)) + return n +} +func (m *SampleOneOf_Field7) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field7)) + return n +} +func (m *SampleOneOf_Field8) Size() (n int) { + var l int + _ = l + n += 1 + sozOne(uint64(m.Field8)) + return n +} +func (m *SampleOneOf_Field9) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field10) Size() (n int) { + var l int + _ = l + n += 5 + return n +} +func (m *SampleOneOf_Field11) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field12) Size() (n int) { + var l int + _ = l + n += 9 + return n +} +func (m *SampleOneOf_Field13) Size() (n int) { + var l int + _ = l + n += 2 + return n +} +func (m *SampleOneOf_Field14) Size() (n int) { + var l int + _ = l + l = len(m.Field14) + n += 1 + l + sovOne(uint64(l)) + return n +} +func (m *SampleOneOf_Field15) Size() (n int) { + var l int + _ = l + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovOne(uint64(l)) + } + return n +} +func (m *SampleOneOf_SubMessage) Size() (n int) { + var l int + _ = l + if m.SubMessage != nil { + l = m.SubMessage.Size() + n += 2 + l + sovOne(uint64(l)) + } + return n +} + +func sovOne(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozOne(x uint64) (n int) { + return sovOne(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Subby) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Subby{`, + `Sub:` + fmt.Sprintf("%v", this.Sub) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf{`, + `TestOneof:` + fmt.Sprintf("%v", this.TestOneof) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field1{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field2{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field3{`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field4) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field4{`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field5) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field5{`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field6) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field6{`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field7) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field7{`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field8) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field8{`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field9) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field9{`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field10) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field10{`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field11) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field11{`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field12) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field12{`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field13) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field13{`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field14) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field14{`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_Field15) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_Field15{`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `}`, + }, "") + return s +} +func (this *SampleOneOf_SubMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SampleOneOf_SubMessage{`, + `SubMessage:` + strings.Replace(fmt.Sprintf("%v", this.SubMessage), "Subby", "Subby", 1) + `,`, + `}`, + }, "") + return s +} +func valueToStringOne(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Subby) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Subby: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Subby: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sub", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Sub = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOneUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOneUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SampleOneOf) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SampleOneOf: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SampleOneOf: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.TestOneof = &SampleOneOf_Field1{v} + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.TestOneof = &SampleOneOf_Field2{v} + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &SampleOneOf_Field3{v} + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &SampleOneOf_Field4{v} + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &SampleOneOf_Field5{v} + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TestOneof = &SampleOneOf_Field6{v} + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.TestOneof = &SampleOneOf_Field7{v} + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.TestOneof = &SampleOneOf_Field8{int64(v)} + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.TestOneof = &SampleOneOf_Field9{v} + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.TestOneof = &SampleOneOf_Field10{v} + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.TestOneof = &SampleOneOf_Field11{v} + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.TestOneof = &SampleOneOf_Field12{v} + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.TestOneof = &SampleOneOf_Field13{b} + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TestOneof = &SampleOneOf_Field14{string(data[iNdEx:postIndex])} + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := make([]byte, postIndex-iNdEx) + copy(v, data[iNdEx:postIndex]) + m.TestOneof = &SampleOneOf_Field15{v} + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubMessage", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthOneUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &Subby{} + if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + m.TestOneof = &SampleOneOf_SubMessage{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipOneUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthOneUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipOneUnsafe(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthOneUnsafe + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowOneUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipOneUnsafe(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthOneUnsafe = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowOneUnsafe = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeunmarshaler/one.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeunmarshaler/one.proto new file mode 100644 index 0000000000000000000000000000000000000000..d9b60c9a904352f532a71910dc36a2edea04be0a --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeunmarshaler/one.proto @@ -0,0 +1,80 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 one; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = true; + +message Subby { + string sub = 1; +} + +message SampleOneOf { + oneof test_oneof { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + int64 Field4 = 4; + uint32 Field5 = 5; + uint64 Field6 = 6; + sint32 Field7 = 7; + sint64 Field8 = 8; + fixed32 Field9 = 9; + sfixed32 Field10 = 10; + fixed64 Field11 = 11; + sfixed64 Field12 = 12; + bool Field13 = 13; + string Field14 = 14; + bytes Field15 = 15; + Subby sub_message = 16; + } +} + + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeunmarshaler/onepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeunmarshaler/onepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..00903a779dfc4aaadc03e0c27c00f595f8868129 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/combos/unsafeunmarshaler/onepb_test.go @@ -0,0 +1,334 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeunmarshaler/one.proto +// DO NOT EDIT! + +/* +Package one is a generated protocol buffer package. + +It is generated from these files: + combos/unsafeunmarshaler/one.proto + +It has these top-level messages: + Subby + SampleOneOf +*/ +package one + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestSubbyProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSampleOneOfProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSubbyJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Subby{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSampleOneOfJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SampleOneOf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSubbyProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubbyProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSampleOneOfProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOneDescription(t *testing.T) { + OneDescription() +} +func TestSubbyVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Subby{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSampleOneOfVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &SampleOneOf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSubbyGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSampleOneOfGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSubbySize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSubby(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSampleOneOfSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSampleOneOf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestSubbyStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSubby(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestSampleOneOfStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSampleOneOf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/doc.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/doc.go new file mode 100644 index 0000000000000000000000000000000000000000..e668df5e0e9fc07ab9c221b6d10ffda6e556fac0 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/doc.go @@ -0,0 +1 @@ +package oneof3 diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/one.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/one.proto new file mode 100644 index 0000000000000000000000000000000000000000..c3cdff7e5e653d662e360759738af0d5bced9860 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneof3/one.proto @@ -0,0 +1,80 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 one; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Subby { + string sub = 1; +} + +message SampleOneOf { + oneof test_oneof { + double Field1 = 1; + float Field2 = 2; + int32 Field3 = 3; + int64 Field4 = 4; + uint32 Field5 = 5; + uint64 Field6 = 6; + sint32 Field7 = 7; + sint64 Field8 = 8; + fixed32 Field9 = 9; + sfixed32 Field10 = 10; + fixed64 Field11 = 11; + sfixed64 Field12 = 12; + bool Field13 = 13; + string Field14 = 14; + bytes Field15 = 15; + Subby sub_message = 16; + } +} + + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneofembed/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneofembed/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..e1c881472029d4273faec457a795ef047cdbe5a2 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneofembed/Makefile @@ -0,0 +1,34 @@ +# 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 --proto_path=../../../../../:../../protobuf/:. --version="3.0.0" --gogo_out=. *.proto + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneofembed/oneofembed.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneofembed/oneofembed.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..10f3d809968eda3368aa532950d76d1fd317514d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneofembed/oneofembed.pb.go @@ -0,0 +1,350 @@ +// Code generated by protoc-gen-gogo. +// source: oneofembed.proto +// DO NOT EDIT! + +/* +Package proto is a generated protocol buffer package. + +It is generated from these files: + oneofembed.proto + +It has these top-level messages: + Foo + Bar +*/ +package proto + +import proto1 "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto1.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Foo struct { + *Bar `protobuf:"bytes,1,opt,name=bar,embedded=bar" json:"bar,omitempty"` +} + +func (m *Foo) Reset() { *m = Foo{} } +func (m *Foo) String() string { return proto1.CompactTextString(m) } +func (*Foo) ProtoMessage() {} + +type Bar struct { + // Types that are valid to be assigned to Pick: + // *Bar_A + // *Bar_B + Pick isBar_Pick `protobuf_oneof:"pick"` +} + +func (m *Bar) Reset() { *m = Bar{} } +func (m *Bar) String() string { return proto1.CompactTextString(m) } +func (*Bar) ProtoMessage() {} + +type isBar_Pick interface { + isBar_Pick() + Equal(interface{}) bool +} + +type Bar_A struct { + A bool `protobuf:"varint,11,opt,name=a,proto3,oneof"` +} +type Bar_B struct { + B bool `protobuf:"varint,12,opt,name=b,proto3,oneof"` +} + +func (*Bar_A) isBar_Pick() {} +func (*Bar_B) isBar_Pick() {} + +func (m *Bar) GetPick() isBar_Pick { + if m != nil { + return m.Pick + } + return nil +} + +func (m *Bar) GetA() bool { + if x, ok := m.GetPick().(*Bar_A); ok { + return x.A + } + return false +} + +func (m *Bar) GetB() bool { + if x, ok := m.GetPick().(*Bar_B); ok { + return x.B + } + return false +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*Bar) XXX_OneofFuncs() (func(msg proto1.Message, b *proto1.Buffer) error, func(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error), []interface{}) { + return _Bar_OneofMarshaler, _Bar_OneofUnmarshaler, []interface{}{ + (*Bar_A)(nil), + (*Bar_B)(nil), + } +} + +func _Bar_OneofMarshaler(msg proto1.Message, b *proto1.Buffer) error { + m := msg.(*Bar) + // pick + switch x := m.Pick.(type) { + case *Bar_A: + t := uint64(0) + if x.A { + t = 1 + } + _ = b.EncodeVarint(11<<3 | proto1.WireVarint) + _ = b.EncodeVarint(t) + case *Bar_B: + t := uint64(0) + if x.B { + t = 1 + } + _ = b.EncodeVarint(12<<3 | proto1.WireVarint) + _ = b.EncodeVarint(t) + case nil: + default: + return fmt.Errorf("Bar.Pick has unexpected type %T", x) + } + return nil +} + +func _Bar_OneofUnmarshaler(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error) { + m := msg.(*Bar) + switch tag { + case 11: // pick.a + if wire != proto1.WireVarint { + return true, proto1.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Pick = &Bar_A{x != 0} + return true, err + case 12: // pick.b + if wire != proto1.WireVarint { + return true, proto1.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Pick = &Bar_B{x != 0} + return true, err + default: + return false, nil + } +} + +func (this *Foo) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Foo) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Bar.Equal(that1.Bar) { + return false + } + return true +} +func (this *Bar) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Bar) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Pick == nil { + if this.Pick != nil { + return false + } + } else if this.Pick == nil { + return false + } else if !this.Pick.Equal(that1.Pick) { + return false + } + return true +} +func (this *Bar_A) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Bar_A) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.A != that1.A { + return false + } + return true +} +func (this *Bar_B) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Bar_B) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.B != that1.B { + return false + } + return true +} +func NewPopulatedFoo(r randyOneofembed, easy bool) *Foo { + this := &Foo{} + if r.Intn(10) != 0 { + this.Bar = NewPopulatedBar(r, easy) + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedBar(r randyOneofembed, easy bool) *Bar { + this := &Bar{} + oneofNumber_Pick := []int32{11, 12}[r.Intn(2)] + switch oneofNumber_Pick { + case 11: + this.Pick = NewPopulatedBar_A(r, easy) + case 12: + this.Pick = NewPopulatedBar_B(r, easy) + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedBar_A(r randyOneofembed, easy bool) *Bar_A { + this := &Bar_A{} + this.A = bool(bool(r.Intn(2) == 0)) + return this +} +func NewPopulatedBar_B(r randyOneofembed, easy bool) *Bar_B { + this := &Bar_B{} + this.B = bool(bool(r.Intn(2) == 0)) + return this +} + +type randyOneofembed interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneOneofembed(r randyOneofembed) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringOneofembed(r randyOneofembed) string { + v1 := r.Intn(100) + tmps := make([]rune, v1) + for i := 0; i < v1; i++ { + tmps[i] = randUTF8RuneOneofembed(r) + } + return string(tmps) +} +func randUnrecognizedOneofembed(r randyOneofembed, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldOneofembed(data, r, fieldNumber, wire) + } + return data +} +func randFieldOneofembed(data []byte, r randyOneofembed, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateOneofembed(data, uint64(key)) + v2 := r.Int63() + if r.Intn(2) == 0 { + v2 *= -1 + } + data = encodeVarintPopulateOneofembed(data, uint64(v2)) + case 1: + data = encodeVarintPopulateOneofembed(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateOneofembed(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateOneofembed(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateOneofembed(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateOneofembed(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneofembed/oneofembed.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneofembed/oneofembed.proto new file mode 100644 index 0000000000000000000000000000000000000000..cf8e5ed0034709bbe0247351927c4d5800622fc0 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneofembed/oneofembed.proto @@ -0,0 +1,18 @@ +syntax = "proto3"; +package proto; +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.populate_all) = true; +option (gogoproto.equal_all) = true; +option (gogoproto.testgen_all) = true; + +message Foo { + Bar bar = 1 [(gogoproto.embed) = true]; +} + +message Bar { + oneof pick { + bool a = 11; + bool b = 12; + } +} \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneofembed/oneofembedpb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneofembed/oneofembedpb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..52196fbf859e35a0a70ff9a35082ab0050cfa131 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/oneofembed/oneofembedpb_test.go @@ -0,0 +1,187 @@ +// Code generated by protoc-gen-gogo. +// source: oneofembed.proto +// DO NOT EDIT! + +/* +Package proto is a generated protocol buffer package. + +It is generated from these files: + oneofembed.proto + +It has these top-level messages: + Foo + Bar +*/ +package proto + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import proto1 "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto1.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestFooProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFoo(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Foo{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestBarProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedBar(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Bar{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestFooJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFoo(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Foo{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestBarJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedBar(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Bar{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestFooProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFoo(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Foo{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFooProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFoo(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Foo{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestBarProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedBar(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Bar{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestBarProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedBar(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Bar{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/packed/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/packed/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..63c75abf35d4f8aed4652946414afc8e7e07c721 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/packed/Makefile @@ -0,0 +1,30 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. packed.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/packed/doc.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/packed/doc.go new file mode 100644 index 0000000000000000000000000000000000000000..e20ab1e9550f8d54b9078e7e41ae1c0959c5a00f --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/packed/doc.go @@ -0,0 +1 @@ +package packed diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/packed/packed.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/packed/packed.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..bc5e8ae08e3de8e9faf9a04f6ff65050faaeb5c2 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/packed/packed.pb.go @@ -0,0 +1,3374 @@ +// Code generated by protoc-gen-gogo. +// source: packed.proto +// DO NOT EDIT! + +/* + Package packed is a generated protocol buffer package. + + It is generated from these files: + packed.proto + + It has these top-level messages: + NinRepNative + NinRepPackedNative + NinRepNativeUnsafe + NinRepPackedNativeUnsafe +*/ +package packed + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import io "io" + +import unsafe "unsafe" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type NinRepNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepNative) Reset() { *m = NinRepNative{} } +func (m *NinRepNative) String() string { return proto.CompactTextString(m) } +func (*NinRepNative) ProtoMessage() {} + +func (m *NinRepNative) GetField1() []float64 { + if m != nil { + return m.Field1 + } + return nil +} + +func (m *NinRepNative) GetField2() []float32 { + if m != nil { + return m.Field2 + } + return nil +} + +func (m *NinRepNative) GetField3() []int32 { + if m != nil { + return m.Field3 + } + return nil +} + +func (m *NinRepNative) GetField4() []int64 { + if m != nil { + return m.Field4 + } + return nil +} + +func (m *NinRepNative) GetField5() []uint32 { + if m != nil { + return m.Field5 + } + return nil +} + +func (m *NinRepNative) GetField6() []uint64 { + if m != nil { + return m.Field6 + } + return nil +} + +func (m *NinRepNative) GetField7() []int32 { + if m != nil { + return m.Field7 + } + return nil +} + +func (m *NinRepNative) GetField8() []int64 { + if m != nil { + return m.Field8 + } + return nil +} + +func (m *NinRepNative) GetField9() []uint32 { + if m != nil { + return m.Field9 + } + return nil +} + +func (m *NinRepNative) GetField10() []int32 { + if m != nil { + return m.Field10 + } + return nil +} + +func (m *NinRepNative) GetField11() []uint64 { + if m != nil { + return m.Field11 + } + return nil +} + +func (m *NinRepNative) GetField12() []int64 { + if m != nil { + return m.Field12 + } + return nil +} + +func (m *NinRepNative) GetField13() []bool { + if m != nil { + return m.Field13 + } + return nil +} + +type NinRepPackedNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepPackedNative) Reset() { *m = NinRepPackedNative{} } +func (m *NinRepPackedNative) String() string { return proto.CompactTextString(m) } +func (*NinRepPackedNative) ProtoMessage() {} + +func (m *NinRepPackedNative) GetField1() []float64 { + if m != nil { + return m.Field1 + } + return nil +} + +func (m *NinRepPackedNative) GetField2() []float32 { + if m != nil { + return m.Field2 + } + return nil +} + +func (m *NinRepPackedNative) GetField3() []int32 { + if m != nil { + return m.Field3 + } + return nil +} + +func (m *NinRepPackedNative) GetField4() []int64 { + if m != nil { + return m.Field4 + } + return nil +} + +func (m *NinRepPackedNative) GetField5() []uint32 { + if m != nil { + return m.Field5 + } + return nil +} + +func (m *NinRepPackedNative) GetField6() []uint64 { + if m != nil { + return m.Field6 + } + return nil +} + +func (m *NinRepPackedNative) GetField7() []int32 { + if m != nil { + return m.Field7 + } + return nil +} + +func (m *NinRepPackedNative) GetField8() []int64 { + if m != nil { + return m.Field8 + } + return nil +} + +func (m *NinRepPackedNative) GetField9() []uint32 { + if m != nil { + return m.Field9 + } + return nil +} + +func (m *NinRepPackedNative) GetField10() []int32 { + if m != nil { + return m.Field10 + } + return nil +} + +func (m *NinRepPackedNative) GetField11() []uint64 { + if m != nil { + return m.Field11 + } + return nil +} + +func (m *NinRepPackedNative) GetField12() []int64 { + if m != nil { + return m.Field12 + } + return nil +} + +func (m *NinRepPackedNative) GetField13() []bool { + if m != nil { + return m.Field13 + } + return nil +} + +type NinRepNativeUnsafe struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepNativeUnsafe) Reset() { *m = NinRepNativeUnsafe{} } +func (m *NinRepNativeUnsafe) String() string { return proto.CompactTextString(m) } +func (*NinRepNativeUnsafe) ProtoMessage() {} + +func (m *NinRepNativeUnsafe) GetField1() []float64 { + if m != nil { + return m.Field1 + } + return nil +} + +func (m *NinRepNativeUnsafe) GetField2() []float32 { + if m != nil { + return m.Field2 + } + return nil +} + +func (m *NinRepNativeUnsafe) GetField3() []int32 { + if m != nil { + return m.Field3 + } + return nil +} + +func (m *NinRepNativeUnsafe) GetField4() []int64 { + if m != nil { + return m.Field4 + } + return nil +} + +func (m *NinRepNativeUnsafe) GetField5() []uint32 { + if m != nil { + return m.Field5 + } + return nil +} + +func (m *NinRepNativeUnsafe) GetField6() []uint64 { + if m != nil { + return m.Field6 + } + return nil +} + +func (m *NinRepNativeUnsafe) GetField7() []int32 { + if m != nil { + return m.Field7 + } + return nil +} + +func (m *NinRepNativeUnsafe) GetField8() []int64 { + if m != nil { + return m.Field8 + } + return nil +} + +func (m *NinRepNativeUnsafe) GetField9() []uint32 { + if m != nil { + return m.Field9 + } + return nil +} + +func (m *NinRepNativeUnsafe) GetField10() []int32 { + if m != nil { + return m.Field10 + } + return nil +} + +func (m *NinRepNativeUnsafe) GetField11() []uint64 { + if m != nil { + return m.Field11 + } + return nil +} + +func (m *NinRepNativeUnsafe) GetField12() []int64 { + if m != nil { + return m.Field12 + } + return nil +} + +func (m *NinRepNativeUnsafe) GetField13() []bool { + if m != nil { + return m.Field13 + } + return nil +} + +type NinRepPackedNativeUnsafe struct { + Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepPackedNativeUnsafe) Reset() { *m = NinRepPackedNativeUnsafe{} } +func (m *NinRepPackedNativeUnsafe) String() string { return proto.CompactTextString(m) } +func (*NinRepPackedNativeUnsafe) ProtoMessage() {} + +func (m *NinRepPackedNativeUnsafe) GetField1() []float64 { + if m != nil { + return m.Field1 + } + return nil +} + +func (m *NinRepPackedNativeUnsafe) GetField2() []float32 { + if m != nil { + return m.Field2 + } + return nil +} + +func (m *NinRepPackedNativeUnsafe) GetField3() []int32 { + if m != nil { + return m.Field3 + } + return nil +} + +func (m *NinRepPackedNativeUnsafe) GetField4() []int64 { + if m != nil { + return m.Field4 + } + return nil +} + +func (m *NinRepPackedNativeUnsafe) GetField5() []uint32 { + if m != nil { + return m.Field5 + } + return nil +} + +func (m *NinRepPackedNativeUnsafe) GetField6() []uint64 { + if m != nil { + return m.Field6 + } + return nil +} + +func (m *NinRepPackedNativeUnsafe) GetField7() []int32 { + if m != nil { + return m.Field7 + } + return nil +} + +func (m *NinRepPackedNativeUnsafe) GetField8() []int64 { + if m != nil { + return m.Field8 + } + return nil +} + +func (m *NinRepPackedNativeUnsafe) GetField9() []uint32 { + if m != nil { + return m.Field9 + } + return nil +} + +func (m *NinRepPackedNativeUnsafe) GetField10() []int32 { + if m != nil { + return m.Field10 + } + return nil +} + +func (m *NinRepPackedNativeUnsafe) GetField11() []uint64 { + if m != nil { + return m.Field11 + } + return nil +} + +func (m *NinRepPackedNativeUnsafe) GetField12() []int64 { + if m != nil { + return m.Field12 + } + return nil +} + +func (m *NinRepPackedNativeUnsafe) GetField13() []bool { + if m != nil { + return m.Field13 + } + return nil +} + +func NewPopulatedNinRepNative(r randyPacked, easy bool) *NinRepNative { + this := &NinRepNative{} + if r.Intn(10) != 0 { + v1 := r.Intn(100) + this.Field1 = make([]float64, v1) + for i := 0; i < v1; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v2 := r.Intn(100) + this.Field2 = make([]float32, v2) + for i := 0; i < v2; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v3 := r.Intn(100) + this.Field3 = make([]int32, v3) + for i := 0; i < v3; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v4 := r.Intn(100) + this.Field4 = make([]int64, v4) + for i := 0; i < v4; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v5 := r.Intn(100) + this.Field5 = make([]uint32, v5) + for i := 0; i < v5; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v6 := r.Intn(100) + this.Field6 = make([]uint64, v6) + for i := 0; i < v6; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v7 := r.Intn(100) + this.Field7 = make([]int32, v7) + for i := 0; i < v7; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v8 := r.Intn(100) + this.Field8 = make([]int64, v8) + for i := 0; i < v8; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v9 := r.Intn(100) + this.Field9 = make([]uint32, v9) + for i := 0; i < v9; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v10 := r.Intn(100) + this.Field10 = make([]int32, v10) + for i := 0; i < v10; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v11 := r.Intn(100) + this.Field11 = make([]uint64, v11) + for i := 0; i < v11; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v12 := r.Intn(100) + this.Field12 = make([]int64, v12) + for i := 0; i < v12; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v13 := r.Intn(100) + this.Field13 = make([]bool, v13) + for i := 0; i < v13; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedPacked(r, 14) + } + return this +} + +func NewPopulatedNinRepPackedNative(r randyPacked, easy bool) *NinRepPackedNative { + this := &NinRepPackedNative{} + if r.Intn(10) != 0 { + v14 := r.Intn(100) + this.Field1 = make([]float64, v14) + for i := 0; i < v14; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v15 := r.Intn(100) + this.Field2 = make([]float32, v15) + for i := 0; i < v15; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v16 := r.Intn(100) + this.Field3 = make([]int32, v16) + for i := 0; i < v16; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v17 := r.Intn(100) + this.Field4 = make([]int64, v17) + for i := 0; i < v17; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v18 := r.Intn(100) + this.Field5 = make([]uint32, v18) + for i := 0; i < v18; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v19 := r.Intn(100) + this.Field6 = make([]uint64, v19) + for i := 0; i < v19; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v20 := r.Intn(100) + this.Field7 = make([]int32, v20) + for i := 0; i < v20; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v21 := r.Intn(100) + this.Field8 = make([]int64, v21) + for i := 0; i < v21; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v22 := r.Intn(100) + this.Field9 = make([]uint32, v22) + for i := 0; i < v22; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v23 := r.Intn(100) + this.Field10 = make([]int32, v23) + for i := 0; i < v23; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v24 := r.Intn(100) + this.Field11 = make([]uint64, v24) + for i := 0; i < v24; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v25 := r.Intn(100) + this.Field12 = make([]int64, v25) + for i := 0; i < v25; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v26 := r.Intn(100) + this.Field13 = make([]bool, v26) + for i := 0; i < v26; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedPacked(r, 14) + } + return this +} + +func NewPopulatedNinRepNativeUnsafe(r randyPacked, easy bool) *NinRepNativeUnsafe { + this := &NinRepNativeUnsafe{} + if r.Intn(10) != 0 { + v27 := r.Intn(100) + this.Field1 = make([]float64, v27) + for i := 0; i < v27; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v28 := r.Intn(100) + this.Field2 = make([]float32, v28) + for i := 0; i < v28; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(100) + this.Field3 = make([]int32, v29) + for i := 0; i < v29; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v30 := r.Intn(100) + this.Field4 = make([]int64, v30) + for i := 0; i < v30; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v31 := r.Intn(100) + this.Field5 = make([]uint32, v31) + for i := 0; i < v31; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v32 := r.Intn(100) + this.Field6 = make([]uint64, v32) + for i := 0; i < v32; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v33 := r.Intn(100) + this.Field7 = make([]int32, v33) + for i := 0; i < v33; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v34 := r.Intn(100) + this.Field8 = make([]int64, v34) + for i := 0; i < v34; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v35 := r.Intn(100) + this.Field9 = make([]uint32, v35) + for i := 0; i < v35; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v36 := r.Intn(100) + this.Field10 = make([]int32, v36) + for i := 0; i < v36; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v37 := r.Intn(100) + this.Field11 = make([]uint64, v37) + for i := 0; i < v37; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v38 := r.Intn(100) + this.Field12 = make([]int64, v38) + for i := 0; i < v38; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v39 := r.Intn(100) + this.Field13 = make([]bool, v39) + for i := 0; i < v39; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedPacked(r, 14) + } + return this +} + +func NewPopulatedNinRepPackedNativeUnsafe(r randyPacked, easy bool) *NinRepPackedNativeUnsafe { + this := &NinRepPackedNativeUnsafe{} + if r.Intn(10) != 0 { + v40 := r.Intn(100) + this.Field1 = make([]float64, v40) + for i := 0; i < v40; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v41 := r.Intn(100) + this.Field2 = make([]float32, v41) + for i := 0; i < v41; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v42 := r.Intn(100) + this.Field3 = make([]int32, v42) + for i := 0; i < v42; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v43 := r.Intn(100) + this.Field4 = make([]int64, v43) + for i := 0; i < v43; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v44 := r.Intn(100) + this.Field5 = make([]uint32, v44) + for i := 0; i < v44; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v45 := r.Intn(100) + this.Field6 = make([]uint64, v45) + for i := 0; i < v45; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v46 := r.Intn(100) + this.Field7 = make([]int32, v46) + for i := 0; i < v46; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v47 := r.Intn(100) + this.Field8 = make([]int64, v47) + for i := 0; i < v47; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v48 := r.Intn(100) + this.Field9 = make([]uint32, v48) + for i := 0; i < v48; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v49 := r.Intn(100) + this.Field10 = make([]int32, v49) + for i := 0; i < v49; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v50 := r.Intn(100) + this.Field11 = make([]uint64, v50) + for i := 0; i < v50; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v51 := r.Intn(100) + this.Field12 = make([]int64, v51) + for i := 0; i < v51; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v52 := r.Intn(100) + this.Field13 = make([]bool, v52) + for i := 0; i < v52; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedPacked(r, 14) + } + return this +} + +type randyPacked interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RunePacked(r randyPacked) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringPacked(r randyPacked) string { + v53 := r.Intn(100) + tmps := make([]rune, v53) + for i := 0; i < v53; i++ { + tmps[i] = randUTF8RunePacked(r) + } + return string(tmps) +} +func randUnrecognizedPacked(r randyPacked, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldPacked(data, r, fieldNumber, wire) + } + return data +} +func randFieldPacked(data []byte, r randyPacked, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulatePacked(data, uint64(key)) + v54 := r.Int63() + if r.Intn(2) == 0 { + v54 *= -1 + } + data = encodeVarintPopulatePacked(data, uint64(v54)) + case 1: + data = encodeVarintPopulatePacked(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulatePacked(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulatePacked(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulatePacked(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulatePacked(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *NinRepNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = append(m.Field9, v) + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = append(m.Field10, v) + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = append(m.Field11, v) + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = append(m.Field12, v) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + default: + iNdEx = preIndex + skippy, err := skipPacked(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthPacked + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepPackedNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepPackedNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepPackedNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPacked + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + } + } else if wireType == 1 { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = append(m.Field1, v2) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + case 2: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPacked + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + } + } else if wireType == 5 { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = append(m.Field2, v2) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + case 3: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPacked + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + case 4: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPacked + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } + } else if wireType == 0 { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + case 5: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPacked + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } + } else if wireType == 0 { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + case 6: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPacked + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + case 7: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPacked + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + case 8: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPacked + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + case 9: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPacked + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = append(m.Field9, v) + } + } else if wireType == 5 { + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = append(m.Field9, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + case 10: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPacked + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = append(m.Field10, v) + } + } else if wireType == 5 { + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = append(m.Field10, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + case 11: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPacked + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = append(m.Field11, v) + } + } else if wireType == 1 { + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = append(m.Field11, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + case 12: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPacked + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = append(m.Field12, v) + } + } else if wireType == 1 { + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = append(m.Field12, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + case 13: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPacked + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } + } else if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPacked + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipPacked(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthPacked + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipPacked(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowPacked + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowPacked + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowPacked + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthPacked + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowPacked + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipPacked(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthPacked = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowPacked = fmt.Errorf("proto: integer overflow") +) + +func (m *NinRepNativeUnsafe) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepNativeUnsafe: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepNativeUnsafe: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = append(m.Field9, v) + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = append(m.Field10, v) + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = append(m.Field11, v) + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = append(m.Field12, v) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + default: + iNdEx = preIndex + skippy, err := skipPackedUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthPackedUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinRepPackedNativeUnsafe) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinRepPackedNativeUnsafe: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinRepPackedNativeUnsafe: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPackedUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + } + } else if wireType == 1 { + var v float64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field1 = append(m.Field1, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + case 2: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPackedUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + } + } else if wireType == 5 { + var v float32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field2 = append(m.Field2, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + case 3: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPackedUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = append(m.Field3, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + case 4: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPackedUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } + } else if wireType == 0 { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = append(m.Field4, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + case 5: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPackedUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } + } else if wireType == 0 { + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = append(m.Field5, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + case 6: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPackedUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = append(m.Field6, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + case 7: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPackedUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } + } else if wireType == 0 { + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = append(m.Field7, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + case 8: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPackedUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } + } else if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = append(m.Field8, int64(v)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + case 9: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPackedUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = append(m.Field9, v) + } + } else if wireType == 5 { + var v uint32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field9 = append(m.Field9, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + case 10: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPackedUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = append(m.Field10, v) + } + } else if wireType == 5 { + var v int32 + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + v = *(*int32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + m.Field10 = append(m.Field10, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + case 11: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPackedUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = append(m.Field11, v) + } + } else if wireType == 1 { + var v uint64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*uint64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field11 = append(m.Field11, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + case 12: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPackedUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = append(m.Field12, v) + } + } else if wireType == 1 { + var v int64 + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + v = *(*int64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + m.Field12 = append(m.Field12, v) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + case 13: + if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + packedLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthPackedUnsafe + } + postIndex := iNdEx + packedLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + for iNdEx < postIndex { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } + } else if wireType == 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = append(m.Field13, bool(v != 0)) + } else { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipPackedUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthPackedUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipPackedUnsafe(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthPackedUnsafe + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowPackedUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipPackedUnsafe(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthPackedUnsafe = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowPackedUnsafe = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/packed/packed.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/packed/packed.proto new file mode 100644 index 0000000000000000000000000000000000000000..29f0e6c87b02c4a446313bf7a0e07025d06cf2db --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/packed/packed.proto @@ -0,0 +1,101 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package packed; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.populate_all) = true; + +message NinRepNative { + option (gogoproto.unmarshaler) = true; + repeated double Field1 = 1; + repeated float Field2 = 2; + repeated int32 Field3 = 3; + repeated int64 Field4 = 4; + repeated uint32 Field5 = 5; + repeated uint64 Field6 = 6; + repeated sint32 Field7 = 7; + repeated sint64 Field8 = 8; + repeated fixed32 Field9 = 9; + repeated sfixed32 Field10 = 10; + repeated fixed64 Field11 = 11; + repeated sfixed64 Field12 = 12; + repeated bool Field13 = 13; +} + +message NinRepPackedNative { + option (gogoproto.unmarshaler) = true; + repeated double Field1 = 1 [packed = true]; + repeated float Field2 = 2 [packed = true]; + repeated int32 Field3 = 3 [packed = true]; + repeated int64 Field4 = 4 [packed = true]; + repeated uint32 Field5 = 5 [packed = true]; + repeated uint64 Field6 = 6 [packed = true]; + repeated sint32 Field7 = 7 [packed = true]; + repeated sint64 Field8 = 8 [packed = true]; + repeated fixed32 Field9 = 9 [packed = true]; + repeated sfixed32 Field10 = 10 [packed = true]; + repeated fixed64 Field11 = 11 [packed = true]; + repeated sfixed64 Field12 = 12 [packed = true]; + repeated bool Field13 = 13 [packed = true]; +} + +message NinRepNativeUnsafe { + option (gogoproto.unsafe_unmarshaler) = true; + repeated double Field1 = 1; + repeated float Field2 = 2; + repeated int32 Field3 = 3; + repeated int64 Field4 = 4; + repeated uint32 Field5 = 5; + repeated uint64 Field6 = 6; + repeated sint32 Field7 = 7; + repeated sint64 Field8 = 8; + repeated fixed32 Field9 = 9; + repeated sfixed32 Field10 = 10; + repeated fixed64 Field11 = 11; + repeated sfixed64 Field12 = 12; + repeated bool Field13 = 13; +} + +message NinRepPackedNativeUnsafe { + option (gogoproto.unsafe_unmarshaler) = true; + repeated double Field1 = 1 [packed = true]; + repeated float Field2 = 2 [packed = true]; + repeated int32 Field3 = 3 [packed = true]; + repeated int64 Field4 = 4 [packed = true]; + repeated uint32 Field5 = 5 [packed = true]; + repeated uint64 Field6 = 6 [packed = true]; + repeated sint32 Field7 = 7 [packed = true]; + repeated sint64 Field8 = 8 [packed = true]; + repeated fixed32 Field9 = 9 [packed = true]; + repeated sfixed32 Field10 = 10 [packed = true]; + repeated fixed64 Field11 = 11 [packed = true]; + repeated sfixed64 Field12 = 12 [packed = true]; + repeated bool Field13 = 13 [packed = true]; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/packed/packed_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/packed/packed_test.go new file mode 100644 index 0000000000000000000000000000000000000000..c43f106e2f724d6c04e39ac07f6ba81841fdfd2d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/packed/packed_test.go @@ -0,0 +1,321 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 packed + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "bytes" + "fmt" + math_rand "math/rand" + "testing" + "time" +) + +/* +https://github.com/gogo/protobuf/issues/detail?id=21 +https://developers.google.com/protocol-buffers/docs/proto#options +In 2.3.0 and later, this change is safe, as parsers for packable fields will always accept both formats, +*/ +func TestSafeIssue21(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + msg1 := NewPopulatedNinRepNative(popr, true) + data1, err := proto.Marshal(msg1) + if err != nil { + panic(err) + } + packedmsg := &NinRepPackedNative{} + err = proto.Unmarshal(data1, packedmsg) + if err != nil { + panic(err) + } + if len(packedmsg.XXX_unrecognized) != 0 { + t.Fatalf("packed msg unmarshaled unrecognized fields, even though there aren't any") + } + if err := VerboseEqual(msg1, packedmsg); err != nil { + t.Fatalf("%v", err) + } +} + +func TestUnsafeIssue21(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + msg1 := NewPopulatedNinRepNativeUnsafe(popr, true) + data1, err := proto.Marshal(msg1) + if err != nil { + panic(err) + } + packedmsg := &NinRepPackedNativeUnsafe{} + err = proto.Unmarshal(data1, packedmsg) + if err != nil { + panic(err) + } + if len(packedmsg.XXX_unrecognized) != 0 { + t.Fatalf("packed msg unmarshaled unrecognized fields, even though there aren't any") + } + if err := VerboseEqualUnsafe(msg1, packedmsg); err != nil { + t.Fatalf("%v", err) + } +} + +func VerboseEqual(this *NinRepNative, that *NinRepPackedNative) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } else if this == nil { + return fmt.Errorf("that != nil && this == nil") + } + + if len(this.Field1) != len(that.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that.Field1[i]) + } + } + if len(this.Field2) != len(that.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that.Field2[i]) + } + } + if len(this.Field3) != len(that.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that.Field3[i]) + } + } + if len(this.Field4) != len(that.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that.Field4[i]) + } + } + if len(this.Field5) != len(that.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that.Field5[i]) + } + } + if len(this.Field6) != len(that.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that.Field6[i]) + } + } + if len(this.Field7) != len(that.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that.Field7[i]) + } + } + if len(this.Field8) != len(that.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that.Field8[i]) + } + } + if len(this.Field9) != len(that.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that.Field9[i]) + } + } + if len(this.Field10) != len(that.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that.Field10[i]) + } + } + if len(this.Field11) != len(that.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that.Field11[i]) + } + } + if len(this.Field12) != len(that.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that.Field12[i]) + } + } + if len(this.Field13) != len(that.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that.Field13[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that.XXX_unrecognized) + } + return nil +} + +func VerboseEqualUnsafe(this *NinRepNativeUnsafe, that *NinRepPackedNativeUnsafe) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } else if this == nil { + return fmt.Errorf("that != nil && this == nil") + } + + if len(this.Field1) != len(that.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that.Field1[i]) + } + } + if len(this.Field2) != len(that.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that.Field2[i]) + } + } + if len(this.Field3) != len(that.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that.Field3[i]) + } + } + if len(this.Field4) != len(that.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that.Field4[i]) + } + } + if len(this.Field5) != len(that.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that.Field5[i]) + } + } + if len(this.Field6) != len(that.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that.Field6[i]) + } + } + if len(this.Field7) != len(that.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that.Field7[i]) + } + } + if len(this.Field8) != len(that.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that.Field8[i]) + } + } + if len(this.Field9) != len(that.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that.Field9[i]) + } + } + if len(this.Field10) != len(that.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that.Field10[i]) + } + } + if len(this.Field11) != len(that.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that.Field11[i]) + } + } + if len(this.Field12) != len(that.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that.Field12[i]) + } + } + if len(this.Field13) != len(that.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that.Field13[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that.XXX_unrecognized) + } + return nil +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/required/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/required/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..37eaecf3cac506cfe193dcb2ae1606bded535c39 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/required/Makefile @@ -0,0 +1,30 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. requiredexample.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/required/requiredexample.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/required/requiredexample.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..4678ebf1b49261c8bb7ef9f8efd15dc52c15d6a1 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/required/requiredexample.pb.go @@ -0,0 +1,2156 @@ +// Code generated by protoc-gen-gogo. +// source: requiredexample.proto +// DO NOT EDIT! + +/* + Package required is a generated protocol buffer package. + + It is generated from these files: + requiredexample.proto + + It has these top-level messages: + RequiredExample + NidOptNative + NinOptNative + NestedNinOptNative +*/ +package required + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type RequiredExample struct { + TheRequiredString *string `protobuf:"bytes,1,req,name=theRequiredString" json:"theRequiredString,omitempty"` + TheOptionalString *string `protobuf:"bytes,2,opt,name=theOptionalString" json:"theOptionalString,omitempty"` + TheRepeatedStrings []string `protobuf:"bytes,3,rep,name=theRepeatedStrings" json:"theRepeatedStrings,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *RequiredExample) Reset() { *m = RequiredExample{} } +func (m *RequiredExample) String() string { return proto.CompactTextString(m) } +func (*RequiredExample) ProtoMessage() {} + +func (m *RequiredExample) GetTheRequiredString() string { + if m != nil && m.TheRequiredString != nil { + return *m.TheRequiredString + } + return "" +} + +func (m *RequiredExample) GetTheOptionalString() string { + if m != nil && m.TheOptionalString != nil { + return *m.TheOptionalString + } + return "" +} + +func (m *RequiredExample) GetTheRepeatedStrings() []string { + if m != nil { + return m.TheRepeatedStrings + } + return nil +} + +type NidOptNative struct { + Field1 float64 `protobuf:"fixed64,1,req,name=Field1" json:"Field1"` + Field2 float32 `protobuf:"fixed32,2,req,name=Field2" json:"Field2"` + Field3 int32 `protobuf:"varint,3,req,name=Field3" json:"Field3"` + Field4 int64 `protobuf:"varint,4,req,name=Field4" json:"Field4"` + Field5 uint32 `protobuf:"varint,5,req,name=Field5" json:"Field5"` + Field6 uint64 `protobuf:"varint,6,req,name=Field6" json:"Field6"` + Field7 int32 `protobuf:"zigzag32,7,req,name=Field7" json:"Field7"` + Field8 int64 `protobuf:"zigzag64,8,req,name=Field8" json:"Field8"` + Field9 uint32 `protobuf:"fixed32,9,req,name=Field9" json:"Field9"` + Field10 int32 `protobuf:"fixed32,10,req,name=Field10" json:"Field10"` + Field11 uint64 `protobuf:"fixed64,11,req,name=Field11" json:"Field11"` + Field12 int64 `protobuf:"fixed64,12,req,name=Field12" json:"Field12"` + Field13 bool `protobuf:"varint,13,req,name=Field13" json:"Field13"` + Field14 string `protobuf:"bytes,14,req,name=Field14" json:"Field14"` + Field15 []byte `protobuf:"bytes,15,req,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptNative) Reset() { *m = NidOptNative{} } +func (m *NidOptNative) String() string { return proto.CompactTextString(m) } +func (*NidOptNative) ProtoMessage() {} + +func (m *NidOptNative) GetField1() float64 { + if m != nil { + return m.Field1 + } + return 0 +} + +func (m *NidOptNative) GetField2() float32 { + if m != nil { + return m.Field2 + } + return 0 +} + +func (m *NidOptNative) GetField3() int32 { + if m != nil { + return m.Field3 + } + return 0 +} + +func (m *NidOptNative) GetField4() int64 { + if m != nil { + return m.Field4 + } + return 0 +} + +func (m *NidOptNative) GetField5() uint32 { + if m != nil { + return m.Field5 + } + return 0 +} + +func (m *NidOptNative) GetField6() uint64 { + if m != nil { + return m.Field6 + } + return 0 +} + +func (m *NidOptNative) GetField7() int32 { + if m != nil { + return m.Field7 + } + return 0 +} + +func (m *NidOptNative) GetField8() int64 { + if m != nil { + return m.Field8 + } + return 0 +} + +func (m *NidOptNative) GetField9() uint32 { + if m != nil { + return m.Field9 + } + return 0 +} + +func (m *NidOptNative) GetField10() int32 { + if m != nil { + return m.Field10 + } + return 0 +} + +func (m *NidOptNative) GetField11() uint64 { + if m != nil { + return m.Field11 + } + return 0 +} + +func (m *NidOptNative) GetField12() int64 { + if m != nil { + return m.Field12 + } + return 0 +} + +func (m *NidOptNative) GetField13() bool { + if m != nil { + return m.Field13 + } + return false +} + +func (m *NidOptNative) GetField14() string { + if m != nil { + return m.Field14 + } + return "" +} + +func (m *NidOptNative) GetField15() []byte { + if m != nil { + return m.Field15 + } + return nil +} + +type NinOptNative struct { + Field1 *float64 `protobuf:"fixed64,1,req,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,req,name=Field2" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,req,name=Field3" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,req,name=Field4" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,req,name=Field5" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,req,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,req,name=Field7" json:"Field7,omitempty"` + Field8 *int64 `protobuf:"zigzag64,8,req,name=Field8" json:"Field8,omitempty"` + Field9 *uint32 `protobuf:"fixed32,9,req,name=Field9" json:"Field9,omitempty"` + Field10 *int32 `protobuf:"fixed32,10,req,name=Field10" json:"Field10,omitempty"` + Field11 *uint64 `protobuf:"fixed64,11,req,name=Field11" json:"Field11,omitempty"` + Field12 *int64 `protobuf:"fixed64,12,req,name=Field12" json:"Field12,omitempty"` + Field13 *bool `protobuf:"varint,13,req,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,req,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,req,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNative) Reset() { *m = NinOptNative{} } +func (m *NinOptNative) String() string { return proto.CompactTextString(m) } +func (*NinOptNative) ProtoMessage() {} + +func (m *NinOptNative) GetField1() float64 { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return 0 +} + +func (m *NinOptNative) GetField2() float32 { + if m != nil && m.Field2 != nil { + return *m.Field2 + } + return 0 +} + +func (m *NinOptNative) GetField3() int32 { + if m != nil && m.Field3 != nil { + return *m.Field3 + } + return 0 +} + +func (m *NinOptNative) GetField4() int64 { + if m != nil && m.Field4 != nil { + return *m.Field4 + } + return 0 +} + +func (m *NinOptNative) GetField5() uint32 { + if m != nil && m.Field5 != nil { + return *m.Field5 + } + return 0 +} + +func (m *NinOptNative) GetField6() uint64 { + if m != nil && m.Field6 != nil { + return *m.Field6 + } + return 0 +} + +func (m *NinOptNative) GetField7() int32 { + if m != nil && m.Field7 != nil { + return *m.Field7 + } + return 0 +} + +func (m *NinOptNative) GetField8() int64 { + if m != nil && m.Field8 != nil { + return *m.Field8 + } + return 0 +} + +func (m *NinOptNative) GetField9() uint32 { + if m != nil && m.Field9 != nil { + return *m.Field9 + } + return 0 +} + +func (m *NinOptNative) GetField10() int32 { + if m != nil && m.Field10 != nil { + return *m.Field10 + } + return 0 +} + +func (m *NinOptNative) GetField11() uint64 { + if m != nil && m.Field11 != nil { + return *m.Field11 + } + return 0 +} + +func (m *NinOptNative) GetField12() int64 { + if m != nil && m.Field12 != nil { + return *m.Field12 + } + return 0 +} + +func (m *NinOptNative) GetField13() bool { + if m != nil && m.Field13 != nil { + return *m.Field13 + } + return false +} + +func (m *NinOptNative) GetField14() string { + if m != nil && m.Field14 != nil { + return *m.Field14 + } + return "" +} + +func (m *NinOptNative) GetField15() []byte { + if m != nil { + return m.Field15 + } + return nil +} + +type NestedNinOptNative struct { + NestedNinOpts []*NinOptNative `protobuf:"bytes,1,rep,name=NestedNinOpts" json:"NestedNinOpts,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedNinOptNative) Reset() { *m = NestedNinOptNative{} } +func (m *NestedNinOptNative) String() string { return proto.CompactTextString(m) } +func (*NestedNinOptNative) ProtoMessage() {} + +func (m *NestedNinOptNative) GetNestedNinOpts() []*NinOptNative { + if m != nil { + return m.NestedNinOpts + } + return nil +} + +func (m *RequiredExample) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *RequiredExample) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.TheRequiredString == nil { + return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("theRequiredString") + } else { + data[i] = 0xa + i++ + i = encodeVarintRequiredexample(data, i, uint64(len(*m.TheRequiredString))) + i += copy(data[i:], *m.TheRequiredString) + } + if m.TheOptionalString != nil { + data[i] = 0x12 + i++ + i = encodeVarintRequiredexample(data, i, uint64(len(*m.TheOptionalString))) + i += copy(data[i:], *m.TheOptionalString) + } + if len(m.TheRepeatedStrings) > 0 { + for _, s := range m.TheRepeatedStrings { + data[i] = 0x1a + i++ + l = len(s) + for l >= 1<<7 { + data[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + data[i] = uint8(l) + i++ + i += copy(data[i:], s) + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NidOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NidOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0x9 + i++ + i = encodeFixed64Requiredexample(data, i, uint64(math.Float64bits(m.Field1))) + data[i] = 0x15 + i++ + i = encodeFixed32Requiredexample(data, i, uint32(math.Float32bits(m.Field2))) + data[i] = 0x18 + i++ + i = encodeVarintRequiredexample(data, i, uint64(m.Field3)) + data[i] = 0x20 + i++ + i = encodeVarintRequiredexample(data, i, uint64(m.Field4)) + data[i] = 0x28 + i++ + i = encodeVarintRequiredexample(data, i, uint64(m.Field5)) + data[i] = 0x30 + i++ + i = encodeVarintRequiredexample(data, i, uint64(m.Field6)) + data[i] = 0x38 + i++ + i = encodeVarintRequiredexample(data, i, uint64((uint32(m.Field7)<<1)^uint32((m.Field7>>31)))) + data[i] = 0x40 + i++ + i = encodeVarintRequiredexample(data, i, uint64((uint64(m.Field8)<<1)^uint64((m.Field8>>63)))) + data[i] = 0x4d + i++ + i = encodeFixed32Requiredexample(data, i, uint32(m.Field9)) + data[i] = 0x55 + i++ + i = encodeFixed32Requiredexample(data, i, uint32(m.Field10)) + data[i] = 0x59 + i++ + i = encodeFixed64Requiredexample(data, i, uint64(m.Field11)) + data[i] = 0x61 + i++ + i = encodeFixed64Requiredexample(data, i, uint64(m.Field12)) + data[i] = 0x68 + i++ + if m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x72 + i++ + i = encodeVarintRequiredexample(data, i, uint64(len(m.Field14))) + i += copy(data[i:], m.Field14) + if m.Field15 != nil { + data[i] = 0x7a + i++ + i = encodeVarintRequiredexample(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NinOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NinOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 == nil { + return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field1") + } else { + data[i] = 0x9 + i++ + i = encodeFixed64Requiredexample(data, i, uint64(math.Float64bits(*m.Field1))) + } + if m.Field2 == nil { + return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field2") + } else { + data[i] = 0x15 + i++ + i = encodeFixed32Requiredexample(data, i, uint32(math.Float32bits(*m.Field2))) + } + if m.Field3 == nil { + return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field3") + } else { + data[i] = 0x18 + i++ + i = encodeVarintRequiredexample(data, i, uint64(*m.Field3)) + } + if m.Field4 == nil { + return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field4") + } else { + data[i] = 0x20 + i++ + i = encodeVarintRequiredexample(data, i, uint64(*m.Field4)) + } + if m.Field5 == nil { + return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field5") + } else { + data[i] = 0x28 + i++ + i = encodeVarintRequiredexample(data, i, uint64(*m.Field5)) + } + if m.Field6 == nil { + return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field6") + } else { + data[i] = 0x30 + i++ + i = encodeVarintRequiredexample(data, i, uint64(*m.Field6)) + } + if m.Field7 == nil { + return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field7") + } else { + data[i] = 0x38 + i++ + i = encodeVarintRequiredexample(data, i, uint64((uint32(*m.Field7)<<1)^uint32((*m.Field7>>31)))) + } + if m.Field8 == nil { + return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field8") + } else { + data[i] = 0x40 + i++ + i = encodeVarintRequiredexample(data, i, uint64((uint64(*m.Field8)<<1)^uint64((*m.Field8>>63)))) + } + if m.Field9 == nil { + return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field9") + } else { + data[i] = 0x4d + i++ + i = encodeFixed32Requiredexample(data, i, uint32(*m.Field9)) + } + if m.Field10 == nil { + return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field10") + } else { + data[i] = 0x55 + i++ + i = encodeFixed32Requiredexample(data, i, uint32(*m.Field10)) + } + if m.Field11 == nil { + return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field11") + } else { + data[i] = 0x59 + i++ + i = encodeFixed64Requiredexample(data, i, uint64(*m.Field11)) + } + if m.Field12 == nil { + return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field12") + } else { + data[i] = 0x61 + i++ + i = encodeFixed64Requiredexample(data, i, uint64(*m.Field12)) + } + if m.Field13 == nil { + return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field13") + } else { + data[i] = 0x68 + i++ + if *m.Field13 { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Field14 == nil { + return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field14") + } else { + data[i] = 0x72 + i++ + i = encodeVarintRequiredexample(data, i, uint64(len(*m.Field14))) + i += copy(data[i:], *m.Field14) + } + if m.Field15 == nil { + return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field15") + } else { + data[i] = 0x7a + i++ + i = encodeVarintRequiredexample(data, i, uint64(len(m.Field15))) + i += copy(data[i:], m.Field15) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *NestedNinOptNative) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NestedNinOptNative) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.NestedNinOpts) > 0 { + for _, msg := range m.NestedNinOpts { + data[i] = 0xa + i++ + i = encodeVarintRequiredexample(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Requiredexample(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Requiredexample(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintRequiredexample(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedRequiredExample(r randyRequiredexample, easy bool) *RequiredExample { + this := &RequiredExample{} + v1 := randStringRequiredexample(r) + this.TheRequiredString = &v1 + if r.Intn(10) != 0 { + v2 := randStringRequiredexample(r) + this.TheOptionalString = &v2 + } + if r.Intn(10) != 0 { + v3 := r.Intn(10) + this.TheRepeatedStrings = make([]string, v3) + for i := 0; i < v3; i++ { + this.TheRepeatedStrings[i] = randStringRequiredexample(r) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedRequiredexample(r, 4) + } + return this +} + +func NewPopulatedNidOptNative(r randyRequiredexample, easy bool) *NidOptNative { + this := &NidOptNative{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + this.Field5 = uint32(r.Uint32()) + this.Field6 = uint64(uint64(r.Uint32())) + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + this.Field9 = uint32(r.Uint32()) + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + this.Field11 = uint64(uint64(r.Uint32())) + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + this.Field13 = bool(bool(r.Intn(2) == 0)) + this.Field14 = randStringRequiredexample(r) + v4 := r.Intn(100) + this.Field15 = make([]byte, v4) + for i := 0; i < v4; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedRequiredexample(r, 16) + } + return this +} + +func NewPopulatedNinOptNative(r randyRequiredexample, easy bool) *NinOptNative { + this := &NinOptNative{} + v5 := float64(r.Float64()) + if r.Intn(2) == 0 { + v5 *= -1 + } + this.Field1 = &v5 + v6 := float32(r.Float32()) + if r.Intn(2) == 0 { + v6 *= -1 + } + this.Field2 = &v6 + v7 := int32(r.Int31()) + if r.Intn(2) == 0 { + v7 *= -1 + } + this.Field3 = &v7 + v8 := int64(r.Int63()) + if r.Intn(2) == 0 { + v8 *= -1 + } + this.Field4 = &v8 + v9 := uint32(r.Uint32()) + this.Field5 = &v9 + v10 := uint64(uint64(r.Uint32())) + this.Field6 = &v10 + v11 := int32(r.Int31()) + if r.Intn(2) == 0 { + v11 *= -1 + } + this.Field7 = &v11 + v12 := int64(r.Int63()) + if r.Intn(2) == 0 { + v12 *= -1 + } + this.Field8 = &v12 + v13 := uint32(r.Uint32()) + this.Field9 = &v13 + v14 := int32(r.Int31()) + if r.Intn(2) == 0 { + v14 *= -1 + } + this.Field10 = &v14 + v15 := uint64(uint64(r.Uint32())) + this.Field11 = &v15 + v16 := int64(r.Int63()) + if r.Intn(2) == 0 { + v16 *= -1 + } + this.Field12 = &v16 + v17 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v17 + v18 := randStringRequiredexample(r) + this.Field14 = &v18 + v19 := r.Intn(100) + this.Field15 = make([]byte, v19) + for i := 0; i < v19; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedRequiredexample(r, 16) + } + return this +} + +func NewPopulatedNestedNinOptNative(r randyRequiredexample, easy bool) *NestedNinOptNative { + this := &NestedNinOptNative{} + if r.Intn(10) != 0 { + v20 := r.Intn(10) + this.NestedNinOpts = make([]*NinOptNative, v20) + for i := 0; i < v20; i++ { + this.NestedNinOpts[i] = NewPopulatedNinOptNative(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedRequiredexample(r, 2) + } + return this +} + +type randyRequiredexample interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneRequiredexample(r randyRequiredexample) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringRequiredexample(r randyRequiredexample) string { + v21 := r.Intn(100) + tmps := make([]rune, v21) + for i := 0; i < v21; i++ { + tmps[i] = randUTF8RuneRequiredexample(r) + } + return string(tmps) +} +func randUnrecognizedRequiredexample(r randyRequiredexample, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldRequiredexample(data, r, fieldNumber, wire) + } + return data +} +func randFieldRequiredexample(data []byte, r randyRequiredexample, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateRequiredexample(data, uint64(key)) + v22 := r.Int63() + if r.Intn(2) == 0 { + v22 *= -1 + } + data = encodeVarintPopulateRequiredexample(data, uint64(v22)) + case 1: + data = encodeVarintPopulateRequiredexample(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateRequiredexample(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateRequiredexample(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateRequiredexample(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateRequiredexample(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *RequiredExample) Size() (n int) { + var l int + _ = l + if m.TheRequiredString != nil { + l = len(*m.TheRequiredString) + n += 1 + l + sovRequiredexample(uint64(l)) + } + if m.TheOptionalString != nil { + l = len(*m.TheOptionalString) + n += 1 + l + sovRequiredexample(uint64(l)) + } + if len(m.TheRepeatedStrings) > 0 { + for _, s := range m.TheRepeatedStrings { + l = len(s) + n += 1 + l + sovRequiredexample(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptNative) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + n += 1 + sovRequiredexample(uint64(m.Field3)) + n += 1 + sovRequiredexample(uint64(m.Field4)) + n += 1 + sovRequiredexample(uint64(m.Field5)) + n += 1 + sovRequiredexample(uint64(m.Field6)) + n += 1 + sozRequiredexample(uint64(m.Field7)) + n += 1 + sozRequiredexample(uint64(m.Field8)) + n += 5 + n += 5 + n += 9 + n += 9 + n += 2 + l = len(m.Field14) + n += 1 + l + sovRequiredexample(uint64(l)) + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovRequiredexample(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNative) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovRequiredexample(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovRequiredexample(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovRequiredexample(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovRequiredexample(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozRequiredexample(uint64(*m.Field7)) + } + if m.Field8 != nil { + n += 1 + sozRequiredexample(uint64(*m.Field8)) + } + if m.Field9 != nil { + n += 5 + } + if m.Field10 != nil { + n += 5 + } + if m.Field11 != nil { + n += 9 + } + if m.Field12 != nil { + n += 9 + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovRequiredexample(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovRequiredexample(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedNinOptNative) Size() (n int) { + var l int + _ = l + if len(m.NestedNinOpts) > 0 { + for _, e := range m.NestedNinOpts { + l = e.Size() + n += 1 + l + sovRequiredexample(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovRequiredexample(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozRequiredexample(x uint64) (n int) { + return sovRequiredexample(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *RequiredExample) Unmarshal(data []byte) error { + var hasFields [1]uint64 + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RequiredExample: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RequiredExample: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TheRequiredString", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRequiredexample + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.TheRequiredString = &s + iNdEx = postIndex + hasFields[0] |= uint64(0x00000001) + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TheOptionalString", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRequiredexample + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.TheOptionalString = &s + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TheRepeatedStrings", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRequiredexample + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TheRepeatedStrings = append(m.TheRepeatedStrings, string(data[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRequiredexample(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRequiredexample + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + if hasFields[0]&uint64(0x00000001) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("theRequiredString") + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NidOptNative) Unmarshal(data []byte) error { + var hasFields [1]uint64 + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NidOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NidOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field1 = float64(math.Float64frombits(v)) + hasFields[0] |= uint64(0x00000001) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field2 = float32(math.Float32frombits(v)) + hasFields[0] |= uint64(0x00000002) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + m.Field3 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field3 |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + hasFields[0] |= uint64(0x00000004) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + m.Field4 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field4 |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + hasFields[0] |= uint64(0x00000008) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + m.Field5 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field5 |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + hasFields[0] |= uint64(0x00000010) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + m.Field6 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Field6 |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + hasFields[0] |= uint64(0x00000020) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = v + hasFields[0] |= uint64(0x00000040) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Field8 = int64(v) + hasFields[0] |= uint64(0x00000080) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + m.Field9 = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + m.Field9 = uint32(data[iNdEx-4]) + m.Field9 |= uint32(data[iNdEx-3]) << 8 + m.Field9 |= uint32(data[iNdEx-2]) << 16 + m.Field9 |= uint32(data[iNdEx-1]) << 24 + hasFields[0] |= uint64(0x00000100) + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + m.Field10 = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + m.Field10 = int32(data[iNdEx-4]) + m.Field10 |= int32(data[iNdEx-3]) << 8 + m.Field10 |= int32(data[iNdEx-2]) << 16 + m.Field10 |= int32(data[iNdEx-1]) << 24 + hasFields[0] |= uint64(0x00000200) + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + m.Field11 = 0 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + m.Field11 = uint64(data[iNdEx-8]) + m.Field11 |= uint64(data[iNdEx-7]) << 8 + m.Field11 |= uint64(data[iNdEx-6]) << 16 + m.Field11 |= uint64(data[iNdEx-5]) << 24 + m.Field11 |= uint64(data[iNdEx-4]) << 32 + m.Field11 |= uint64(data[iNdEx-3]) << 40 + m.Field11 |= uint64(data[iNdEx-2]) << 48 + m.Field11 |= uint64(data[iNdEx-1]) << 56 + hasFields[0] |= uint64(0x00000400) + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + m.Field12 = 0 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + m.Field12 = int64(data[iNdEx-8]) + m.Field12 |= int64(data[iNdEx-7]) << 8 + m.Field12 |= int64(data[iNdEx-6]) << 16 + m.Field12 |= int64(data[iNdEx-5]) << 24 + m.Field12 |= int64(data[iNdEx-4]) << 32 + m.Field12 |= int64(data[iNdEx-3]) << 40 + m.Field12 |= int64(data[iNdEx-2]) << 48 + m.Field12 |= int64(data[iNdEx-1]) << 56 + hasFields[0] |= uint64(0x00000800) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field13 = bool(v != 0) + hasFields[0] |= uint64(0x00001000) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRequiredexample + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field14 = string(data[iNdEx:postIndex]) + iNdEx = postIndex + hasFields[0] |= uint64(0x00002000) + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthRequiredexample + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + hasFields[0] |= uint64(0x00004000) + default: + iNdEx = preIndex + skippy, err := skipRequiredexample(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRequiredexample + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + if hasFields[0]&uint64(0x00000001) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field1") + } + if hasFields[0]&uint64(0x00000002) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field2") + } + if hasFields[0]&uint64(0x00000004) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field3") + } + if hasFields[0]&uint64(0x00000008) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field4") + } + if hasFields[0]&uint64(0x00000010) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field5") + } + if hasFields[0]&uint64(0x00000020) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field6") + } + if hasFields[0]&uint64(0x00000040) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field7") + } + if hasFields[0]&uint64(0x00000080) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field8") + } + if hasFields[0]&uint64(0x00000100) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field9") + } + if hasFields[0]&uint64(0x00000200) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field10") + } + if hasFields[0]&uint64(0x00000400) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field11") + } + if hasFields[0]&uint64(0x00000800) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field12") + } + if hasFields[0]&uint64(0x00001000) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field13") + } + if hasFields[0]&uint64(0x00002000) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field14") + } + if hasFields[0]&uint64(0x00004000) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field15") + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NinOptNative) Unmarshal(data []byte) error { + var hasFields [1]uint64 + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NinOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NinOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field1 = &v2 + hasFields[0] |= uint64(0x00000001) + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field2 = &v2 + hasFields[0] |= uint64(0x00000002) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = &v + hasFields[0] |= uint64(0x00000004) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field4 = &v + hasFields[0] |= uint64(0x00000008) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field5 = &v + hasFields[0] |= uint64(0x00000010) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + hasFields[0] |= uint64(0x00000020) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Field7 = &v + hasFields[0] |= uint64(0x00000040) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field8", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + v2 := int64(v) + m.Field8 = &v2 + hasFields[0] |= uint64(0x00000080) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field9", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Field9 = &v + hasFields[0] |= uint64(0x00000100) + case 10: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field10", wireType) + } + var v int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = int32(data[iNdEx-4]) + v |= int32(data[iNdEx-3]) << 8 + v |= int32(data[iNdEx-2]) << 16 + v |= int32(data[iNdEx-1]) << 24 + m.Field10 = &v + hasFields[0] |= uint64(0x00000200) + case 11: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field11", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.Field11 = &v + hasFields[0] |= uint64(0x00000400) + case 12: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field12", wireType) + } + var v int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = int64(data[iNdEx-8]) + v |= int64(data[iNdEx-7]) << 8 + v |= int64(data[iNdEx-6]) << 16 + v |= int64(data[iNdEx-5]) << 24 + v |= int64(data[iNdEx-4]) << 32 + v |= int64(data[iNdEx-3]) << 40 + v |= int64(data[iNdEx-2]) << 48 + v |= int64(data[iNdEx-1]) << 56 + m.Field12 = &v + hasFields[0] |= uint64(0x00000800) + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field13", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Field13 = &b + hasFields[0] |= uint64(0x00001000) + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field14", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRequiredexample + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field14 = &s + iNdEx = postIndex + hasFields[0] |= uint64(0x00002000) + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field15", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthRequiredexample + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field15 = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + hasFields[0] |= uint64(0x00004000) + default: + iNdEx = preIndex + skippy, err := skipRequiredexample(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRequiredexample + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + if hasFields[0]&uint64(0x00000001) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field1") + } + if hasFields[0]&uint64(0x00000002) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field2") + } + if hasFields[0]&uint64(0x00000004) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field3") + } + if hasFields[0]&uint64(0x00000008) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field4") + } + if hasFields[0]&uint64(0x00000010) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field5") + } + if hasFields[0]&uint64(0x00000020) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field6") + } + if hasFields[0]&uint64(0x00000040) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field7") + } + if hasFields[0]&uint64(0x00000080) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field8") + } + if hasFields[0]&uint64(0x00000100) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field9") + } + if hasFields[0]&uint64(0x00000200) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field10") + } + if hasFields[0]&uint64(0x00000400) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field11") + } + if hasFields[0]&uint64(0x00000800) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field12") + } + if hasFields[0]&uint64(0x00001000) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field13") + } + if hasFields[0]&uint64(0x00002000) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field14") + } + if hasFields[0]&uint64(0x00004000) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Field15") + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NestedNinOptNative) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NestedNinOptNative: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NestedNinOptNative: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NestedNinOpts", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthRequiredexample + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NestedNinOpts = append(m.NestedNinOpts, &NinOptNative{}) + if err := m.NestedNinOpts[len(m.NestedNinOpts)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipRequiredexample(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthRequiredexample + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipRequiredexample(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthRequiredexample + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowRequiredexample + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipRequiredexample(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthRequiredexample = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowRequiredexample = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/required/requiredexample.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/required/requiredexample.proto new file mode 100644 index 0000000000000000000000000000000000000000..a86feb416b037300cbd99a3ac87560490d30861f --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/required/requiredexample.proto @@ -0,0 +1,55 @@ +syntax = "proto2"; +package required; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.populate_all) = true; + +message RequiredExample { + required string theRequiredString = 1; + optional string theOptionalString = 2; + repeated string theRepeatedStrings = 3; +} + +message NidOptNative { + required double Field1 = 1 [(gogoproto.nullable) = false]; + required float Field2 = 2 [(gogoproto.nullable) = false]; + required int32 Field3 = 3 [(gogoproto.nullable) = false]; + required int64 Field4 = 4 [(gogoproto.nullable) = false]; + required uint32 Field5 = 5 [(gogoproto.nullable) = false]; + required uint64 Field6 = 6 [(gogoproto.nullable) = false]; + required sint32 Field7 = 7 [(gogoproto.nullable) = false]; + required sint64 Field8 = 8 [(gogoproto.nullable) = false]; + required fixed32 Field9 = 9 [(gogoproto.nullable) = false]; + required sfixed32 Field10 = 10 [(gogoproto.nullable) = false]; + required fixed64 Field11 = 11 [(gogoproto.nullable) = false]; + required sfixed64 Field12 = 12 [(gogoproto.nullable) = false]; + required bool Field13 = 13 [(gogoproto.nullable) = false]; + required string Field14 = 14 [(gogoproto.nullable) = false]; + required bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinOptNative { + required double Field1 = 1; + required float Field2 = 2; + required int32 Field3 = 3; + required int64 Field4 = 4; + required uint32 Field5 = 5; + required uint64 Field6 = 6; + required sint32 Field7 = 7; + required sint64 Field8 = 8; + required fixed32 Field9 = 9; + required sfixed32 Field10 = 10; + required fixed64 Field11 = 11; + required sfixed64 Field12 = 12; + required bool Field13 = 13; + required string Field14 = 14; + required bytes Field15 = 15; +} + +message NestedNinOptNative { + repeated NinOptNative NestedNinOpts = 1; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/required/requiredexamplepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/required/requiredexamplepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..ec222d0a5b62ffbafc822c3c15338bdf3b62697c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/required/requiredexamplepb_test.go @@ -0,0 +1,153 @@ +package required + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test" + "math/rand" + "reflect" + "strconv" + "testing" + "time" +) + +func TestMarshalToErrorsWhenRequiredFieldIsNotPresent(t *testing.T) { + data := RequiredExample{} + buf, err := proto.Marshal(&data) + if err == nil { + t.Fatalf("err == nil; was %v instead", err) + } + if err.Error() != `proto: required field "theRequiredString" not set` { + t.Fatalf(`err.Error() != "proto: required field "theRequiredString" not set"; was "%s" instead`, err.Error()) + } + if len(buf) != 0 { + t.Fatalf(`len(buf) != 0; was %d instead`, len(buf)) + } +} + +func TestMarshalToSucceedsWhenRequiredFieldIsPresent(t *testing.T) { + data := RequiredExample{ + TheRequiredString: proto.String("present"), + } + buf, err := proto.Marshal(&data) + if err != nil { + t.Fatalf("err != nil; was %v instead", err) + } + if len(buf) == 0 { + t.Fatalf(`len(buf) == 0; expected nonzero`) + } +} + +func TestUnmarshalErrorsWhenRequiredFieldIsNotPresent(t *testing.T) { + missingRequiredField := []byte{0x12, 0x8, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c} + data := RequiredExample{} + err := proto.Unmarshal(missingRequiredField, &data) + if err == nil { + t.Fatalf("err == nil; was %v instead", err) + } + if err.Error() != `proto: required field "theRequiredString" not set` { + t.Fatalf(`err.Error() != "proto: required field "theRequiredString" not set"; was "%s" instead`, err.Error()) + } +} + +func TestUnmarshalSucceedsWhenRequiredIsNotPresent(t *testing.T) { + dataOut := RequiredExample{ + TheRequiredString: proto.String("present"), + } + encodedMessage, err := proto.Marshal(&dataOut) + if err != nil { + t.Fatalf("Unexpected error when marshalling dataOut: %v", err) + } + dataIn := RequiredExample{} + err = proto.Unmarshal(encodedMessage, &dataIn) + if err != nil { + t.Fatalf("err != nil; was %v instead", err) + } +} + +func TestUnmarshalPopulatedOptionalFieldsAsRequiredSucceeds(t *testing.T) { + r := rand.New(rand.NewSource(time.Now().UnixNano())) + dataOut := test.NewPopulatedNidOptNative(r, true) + encodedMessage, err := proto.Marshal(dataOut) + if err != nil { + t.Fatalf("Unexpected error when marshalling dataOut: %v", err) + } + dataIn := NidOptNative{} + err = proto.Unmarshal(encodedMessage, &dataIn) + if err != nil { + t.Fatalf("err != nil; was %v instead", err) + } +} + +func TestUnmarshalPartiallyPopulatedOptionalFieldsFails(t *testing.T) { + // Fill in all fields, then randomly remove one. + dataOut := &test.NinOptNative{ + Field1: proto.Float64(0), + Field2: proto.Float32(0), + Field3: proto.Int32(0), + Field4: proto.Int64(0), + Field5: proto.Uint32(0), + Field6: proto.Uint64(0), + Field7: proto.Int32(0), + Field8: proto.Int64(0), + Field9: proto.Uint32(0), + Field10: proto.Int32(0), + Field11: proto.Uint64(0), + Field12: proto.Int64(0), + Field13: proto.Bool(false), + Field14: proto.String("0"), + Field15: []byte("0"), + } + r := rand.New(rand.NewSource(time.Now().UnixNano())) + fieldName := "Field" + strconv.Itoa(r.Intn(15)+1) + field := reflect.ValueOf(dataOut).Elem().FieldByName(fieldName) + fieldType := field.Type() + field.Set(reflect.Zero(fieldType)) + encodedMessage, err := proto.Marshal(dataOut) + if err != nil { + t.Fatalf("Unexpected error when marshalling dataOut: %v", err) + } + dataIn := NidOptNative{} + err = proto.Unmarshal(encodedMessage, &dataIn) + if err.Error() != `proto: required field "`+fieldName+`" not set` { + t.Fatalf(`err.Error() != "proto: required field "`+fieldName+`" not set"; was "%s" instead`, err.Error()) + } +} + +func TestMarshalFailsWithoutAllFieldsSet(t *testing.T) { + r := rand.New(rand.NewSource(time.Now().UnixNano())) + dataOut := NewPopulatedNinOptNative(r, true) + fieldName := "Field" + strconv.Itoa(r.Intn(15)+1) + field := reflect.ValueOf(dataOut).Elem().FieldByName(fieldName) + fieldType := field.Type() + field.Set(reflect.Zero(fieldType)) + encodedMessage, err := proto.Marshal(dataOut) + if err.Error() != `proto: required field "`+fieldName+`" not set` { + t.Fatalf(`err.Error() != "proto: required field "`+fieldName+`" not set"; was "%s" instead`, err.Error()) + } + if len(encodedMessage) > 0 { + t.Fatalf("Got some bytes from marshal, expected none.") + } +} + +func TestMissingFieldsOnRepeatedNestedTypes(t *testing.T) { + r := rand.New(rand.NewSource(time.Now().UnixNano())) + dataOut := &NestedNinOptNative{ + NestedNinOpts: []*NinOptNative{ + NewPopulatedNinOptNative(r, true), + NewPopulatedNinOptNative(r, true), + NewPopulatedNinOptNative(r, true), + }, + } + middle := dataOut.GetNestedNinOpts()[1] + fieldName := "Field" + strconv.Itoa(r.Intn(15)+1) + field := reflect.ValueOf(middle).Elem().FieldByName(fieldName) + fieldType := field.Type() + field.Set(reflect.Zero(fieldType)) + encodedMessage, err := proto.Marshal(dataOut) + if err.Error() != `proto: required field "`+fieldName+`" not set` { + t.Fatalf(`err.Error() != "proto: required field "`+fieldName+`" not set"; was "%s" instead`, err.Error()) + } + if len(encodedMessage) > 0 { + t.Fatalf("Got some bytes from marshal, expected none.") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/sizeunderscore/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/sizeunderscore/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..4cc62baaad0a003124a2b32a7570565d64acc27b --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/sizeunderscore/Makefile @@ -0,0 +1,30 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. sizeunderscore.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/sizeunderscore/sizeunderscore.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/sizeunderscore/sizeunderscore.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..d84151b3d33ffe12b0a91334f66958ec630650a7 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/sizeunderscore/sizeunderscore.pb.go @@ -0,0 +1,536 @@ +// Code generated by protoc-gen-gogo. +// source: sizeunderscore.proto +// DO NOT EDIT! + +/* + Package sizeunderscore is a generated protocol buffer package. + + It is generated from these files: + sizeunderscore.proto + + It has these top-level messages: + SizeMessage +*/ +package sizeunderscore + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import bytes "bytes" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type SizeMessage struct { + Size_ *int64 `protobuf:"varint,1,opt,name=size" json:"size,omitempty"` + Equal_ *bool `protobuf:"varint,2,opt,name=Equal" json:"Equal,omitempty"` + String_ *string `protobuf:"bytes,3,opt,name=String" json:"String,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SizeMessage) Reset() { *m = SizeMessage{} } +func (m *SizeMessage) String() string { return proto.CompactTextString(m) } +func (*SizeMessage) ProtoMessage() {} + +func (m *SizeMessage) GetSize_() int64 { + if m != nil && m.Size_ != nil { + return *m.Size_ + } + return 0 +} + +func (m *SizeMessage) GetEqual_() bool { + if m != nil && m.Equal_ != nil { + return *m.Equal_ + } + return false +} + +func (m *SizeMessage) GetString_() string { + if m != nil && m.String_ != nil { + return *m.String_ + } + return "" +} + +func (this *SizeMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*SizeMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Size_ != nil && that1.Size_ != nil { + if *this.Size_ != *that1.Size_ { + return false + } + } else if this.Size_ != nil { + return false + } else if that1.Size_ != nil { + return false + } + if this.Equal_ != nil && that1.Equal_ != nil { + if *this.Equal_ != *that1.Equal_ { + return false + } + } else if this.Equal_ != nil { + return false + } else if that1.Equal_ != nil { + return false + } + if this.String_ != nil && that1.String_ != nil { + if *this.String_ != *that1.String_ { + return false + } + } else if this.String_ != nil { + return false + } else if that1.String_ != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (m *SizeMessage) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *SizeMessage) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Size_ != nil { + data[i] = 0x8 + i++ + i = encodeVarintSizeunderscore(data, i, uint64(*m.Size_)) + } + if m.Equal_ != nil { + data[i] = 0x10 + i++ + if *m.Equal_ { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.String_ != nil { + data[i] = 0x1a + i++ + i = encodeVarintSizeunderscore(data, i, uint64(len(*m.String_))) + i += copy(data[i:], *m.String_) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Sizeunderscore(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Sizeunderscore(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintSizeunderscore(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedSizeMessage(r randySizeunderscore, easy bool) *SizeMessage { + this := &SizeMessage{} + if r.Intn(10) != 0 { + v1 := int64(r.Int63()) + if r.Intn(2) == 0 { + v1 *= -1 + } + this.Size_ = &v1 + } + if r.Intn(10) != 0 { + v2 := bool(bool(r.Intn(2) == 0)) + this.Equal_ = &v2 + } + if r.Intn(10) != 0 { + v3 := randStringSizeunderscore(r) + this.String_ = &v3 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedSizeunderscore(r, 4) + } + return this +} + +type randySizeunderscore interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneSizeunderscore(r randySizeunderscore) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringSizeunderscore(r randySizeunderscore) string { + v4 := r.Intn(100) + tmps := make([]rune, v4) + for i := 0; i < v4; i++ { + tmps[i] = randUTF8RuneSizeunderscore(r) + } + return string(tmps) +} +func randUnrecognizedSizeunderscore(r randySizeunderscore, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldSizeunderscore(data, r, fieldNumber, wire) + } + return data +} +func randFieldSizeunderscore(data []byte, r randySizeunderscore, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateSizeunderscore(data, uint64(key)) + v5 := r.Int63() + if r.Intn(2) == 0 { + v5 *= -1 + } + data = encodeVarintPopulateSizeunderscore(data, uint64(v5)) + case 1: + data = encodeVarintPopulateSizeunderscore(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateSizeunderscore(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateSizeunderscore(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateSizeunderscore(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateSizeunderscore(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *SizeMessage) Size() (n int) { + var l int + _ = l + if m.Size_ != nil { + n += 1 + sovSizeunderscore(uint64(*m.Size_)) + } + if m.Equal_ != nil { + n += 2 + } + if m.String_ != nil { + l = len(*m.String_) + n += 1 + l + sovSizeunderscore(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovSizeunderscore(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozSizeunderscore(x uint64) (n int) { + return sovSizeunderscore(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *SizeMessage) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSizeunderscore + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SizeMessage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SizeMessage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSizeunderscore + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Size_ = &v + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Equal_", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSizeunderscore + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + b := bool(v != 0) + m.Equal_ = &b + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field String_", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSizeunderscore + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthSizeunderscore + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.String_ = &s + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSizeunderscore(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthSizeunderscore + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipSizeunderscore(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSizeunderscore + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSizeunderscore + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSizeunderscore + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthSizeunderscore + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowSizeunderscore + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipSizeunderscore(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthSizeunderscore = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowSizeunderscore = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/sizeunderscore/sizeunderscore.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/sizeunderscore/sizeunderscore.proto new file mode 100644 index 0000000000000000000000000000000000000000..75db22ff01a24d5e1e1c36cbabf39503873dbb1f --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/sizeunderscore/sizeunderscore.proto @@ -0,0 +1,17 @@ +syntax = "proto2"; +package sizeunderscore; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.testgen_all) = true; +option (gogoproto.equal_all) = true; + +message SizeMessage { + optional int64 size = 1; + optional bool Equal = 2; + optional string String = 3; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/sizeunderscore/sizeunderscorepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/sizeunderscore/sizeunderscorepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..9191a1ac6cfbb0c7fc5a6f3bca3f45ec612f3d03 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/sizeunderscore/sizeunderscorepb_test.go @@ -0,0 +1,156 @@ +// Code generated by protoc-gen-gogo. +// source: sizeunderscore.proto +// DO NOT EDIT! + +/* +Package sizeunderscore is a generated protocol buffer package. + +It is generated from these files: + sizeunderscore.proto + +It has these top-level messages: + SizeMessage +*/ +package sizeunderscore + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestSizeMessageProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSizeMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SizeMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestSizeMessageMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSizeMessage(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SizeMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSizeMessageJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSizeMessage(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &SizeMessage{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSizeMessageProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSizeMessage(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &SizeMessage{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSizeMessageProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSizeMessage(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &SizeMessage{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSizeMessageSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSizeMessage(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/tags/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/tags/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..ade15ceab82dbeb18c2ee75e8e0c4fdf7893c5fb --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/tags/Makefile @@ -0,0 +1,30 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. tags.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/tags/doc.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/tags/doc.go new file mode 100644 index 0000000000000000000000000000000000000000..2eee9618471cdc8e9dab309432f99c71f5dcef43 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/tags/doc.go @@ -0,0 +1 @@ +package tags diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/tags/tags.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/tags/tags.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..d91643176ee63ff43f67d574ad483b2a78f90488 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/tags/tags.pb.go @@ -0,0 +1,159 @@ +// Code generated by protoc-gen-gogo. +// source: tags.proto +// DO NOT EDIT! + +/* +Package tags is a generated protocol buffer package. + +It is generated from these files: + tags.proto + +It has these top-level messages: + Outside + Inside +*/ +package tags + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Outside struct { + *Inside `protobuf:"bytes,1,opt,name=Inside,embedded=Inside" json:""` + Field2 *string `protobuf:"bytes,2,opt,name=Field2" json:"MyField2" xml:",comment"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Outside) Reset() { *m = Outside{} } +func (m *Outside) String() string { return proto.CompactTextString(m) } +func (*Outside) ProtoMessage() {} + +func (m *Outside) GetField2() string { + if m != nil && m.Field2 != nil { + return *m.Field2 + } + return "" +} + +type Inside struct { + Field1 *string `protobuf:"bytes,1,opt,name=Field1" json:"MyField1" xml:",chardata"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Inside) Reset() { *m = Inside{} } +func (m *Inside) String() string { return proto.CompactTextString(m) } +func (*Inside) ProtoMessage() {} + +func (m *Inside) GetField1() string { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return "" +} + +func NewPopulatedOutside(r randyTags, easy bool) *Outside { + this := &Outside{} + if r.Intn(10) != 0 { + this.Inside = NewPopulatedInside(r, easy) + } + if r.Intn(10) != 0 { + v1 := randStringTags(r) + this.Field2 = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedTags(r, 3) + } + return this +} + +func NewPopulatedInside(r randyTags, easy bool) *Inside { + this := &Inside{} + if r.Intn(10) != 0 { + v2 := randStringTags(r) + this.Field1 = &v2 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedTags(r, 2) + } + return this +} + +type randyTags interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneTags(r randyTags) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringTags(r randyTags) string { + v3 := r.Intn(100) + tmps := make([]rune, v3) + for i := 0; i < v3; i++ { + tmps[i] = randUTF8RuneTags(r) + } + return string(tmps) +} +func randUnrecognizedTags(r randyTags, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldTags(data, r, fieldNumber, wire) + } + return data +} +func randFieldTags(data []byte, r randyTags, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateTags(data, uint64(key)) + v4 := r.Int63() + if r.Intn(2) == 0 { + v4 *= -1 + } + data = encodeVarintPopulateTags(data, uint64(v4)) + case 1: + data = encodeVarintPopulateTags(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateTags(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateTags(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateTags(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateTags(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/tags/tags.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/tags/tags.proto new file mode 100644 index 0000000000000000000000000000000000000000..e5b3a4faa11dad400179650591d2b6ce9965af32 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/tags/tags.proto @@ -0,0 +1,42 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package tags; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.populate_all) = true; + +message Outside { + optional Inside Inside = 1 [(gogoproto.embed) = true, (gogoproto.jsontag) = ""]; + optional string Field2 = 2 [(gogoproto.jsontag) = "MyField2", (gogoproto.moretags) = "xml:\",comment\""]; +} + +message Inside { + optional string Field1 = 1 [(gogoproto.jsontag) = "MyField1", (gogoproto.moretags) = "xml:\",chardata\""]; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/tags/tags_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/tags/tags_test.go new file mode 100644 index 0000000000000000000000000000000000000000..0ab3ba34ec50c12150632664d85b4f99a3ae2aaa --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/tags/tags_test.go @@ -0,0 +1,117 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 tags + +import ( + "bytes" + "encoding/json" + "encoding/xml" + math_rand "math/rand" + "testing" + "time" +) + +type MyJson struct { + MyField1 string + MyField2 string +} + +func NewPopulatedMyJson(r randyTags) *MyJson { + this := &MyJson{} + if r.Intn(10) != 0 { + this.MyField1 = randStringTags(r) + } + if r.Intn(10) != 0 { + this.MyField2 = randStringTags(r) + } + return this +} + +func TestJson(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + msg1 := NewPopulatedMyJson(popr) + data, err := json.Marshal(msg1) + if err != nil { + panic(err) + } + outside := &Outside{} + err = json.Unmarshal(data, outside) + if err != nil { + panic(err) + } + if outside.GetField1() != msg1.MyField1 { + t.Fatalf("proto field1 %s != %s", outside.GetField1(), msg1.MyField1) + } + if outside.GetField2() != msg1.MyField2 { + t.Fatalf("proto field2 %s != %s", outside.GetField2(), msg1.MyField2) + } + data2, err := json.Marshal(outside) + if err != nil { + panic(err) + } + msg2 := &MyJson{} + err = json.Unmarshal(data2, msg2) + if err != nil { + panic(err) + } + if msg2.MyField1 != msg1.MyField1 { + t.Fatalf("proto field1 %s != %s", msg2.MyField1, msg1.MyField1) + } + if msg2.MyField2 != msg1.MyField2 { + t.Fatalf("proto field2 %s != %s", msg2.MyField2, msg1.MyField2) + } +} + +func TestXml(t *testing.T) { + s := "Field1Value" + field1 := "Field1Value" + field2 := "Field2Value" + msg1 := &Outside{} + err := xml.Unmarshal([]byte(s), msg1) + if err != nil { + panic(err) + } + msg2 := &Outside{ + Inside: &Inside{ + Field1: &field1, + }, + Field2: &field2, + } + if msg1.GetField1() != msg2.GetField1() { + t.Fatalf("field1 expected %s got %s", msg2.GetField1(), msg1.GetField1()) + } + if err != nil { + panic(err) + } + data, err := xml.Marshal(msg2) + if err != nil { + panic(err) + } + if !bytes.Equal(data, []byte(s)) { + t.Fatalf("expected %s got %s", s, string(data)) + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..dbfcda56f28d8257f7dbace5c02a35830fd0ca16 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/Makefile @@ -0,0 +1,34 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/protobuf/gogoproto +# +# 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. +# +# 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: + cp header.proto theproto3.proto + cat maps.proto >> theproto3.proto + cat footer.proto >> theproto3.proto + go install github.com/gogo/protobuf/protoc-gen-combo + protoc-gen-combo --version="3.0.0" --proto_path=../../../../../:../../protobuf/:. theproto3.proto \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/both/nilmaps_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/both/nilmaps_test.go new file mode 100644 index 0000000000000000000000000000000000000000..1b05c72b2c453fe78cac35296c395d0dc5951bc8 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/both/nilmaps_test.go @@ -0,0 +1,39 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 theproto3 + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "testing" +) + +func TestNilMaps(t *testing.T) { + m := &AllMaps{StringToMsgMap: map[string]*FloatingPoint{"a": nil}} + if _, err := proto.Marshal(m); err == nil { + t.Fatalf("expected error") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/both/theproto3.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/both/theproto3.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..75daaf24727c62990f72544b81bba969d9a7c417 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/both/theproto3.pb.go @@ -0,0 +1,11071 @@ +// Code generated by protoc-gen-gogo. +// source: combos/both/theproto3.proto +// DO NOT EDIT! + +/* + Package theproto3 is a generated protocol buffer package. + + It is generated from these files: + combos/both/theproto3.proto + + It has these top-level messages: + Message + Nested + AllMaps + MessageWithMap + FloatingPoint +*/ +package theproto3 + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" +import test "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" +import github_com_gogo_protobuf_sortkeys "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/sortkeys" + +import errors "errors" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type MapEnum int32 + +const ( + MA MapEnum = 0 + MB MapEnum = 1 + MC MapEnum = 2 +) + +var MapEnum_name = map[int32]string{ + 0: "MA", + 1: "MB", + 2: "MC", +} +var MapEnum_value = map[string]int32{ + "MA": 0, + "MB": 1, + "MC": 2, +} + +type Message_Humour int32 + +const ( + UNKNOWN Message_Humour = 0 + PUNS Message_Humour = 1 + SLAPSTICK Message_Humour = 2 + BILL_BAILEY Message_Humour = 3 +) + +var Message_Humour_name = map[int32]string{ + 0: "UNKNOWN", + 1: "PUNS", + 2: "SLAPSTICK", + 3: "BILL_BAILEY", +} +var Message_Humour_value = map[string]int32{ + "UNKNOWN": 0, + "PUNS": 1, + "SLAPSTICK": 2, + "BILL_BAILEY": 3, +} + +type Message struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Hilarity Message_Humour `protobuf:"varint,2,opt,name=hilarity,proto3,enum=theproto3.Message_Humour" json:"hilarity,omitempty"` + HeightInCm uint32 `protobuf:"varint,3,opt,name=height_in_cm,proto3" json:"height_in_cm,omitempty"` + Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` + ResultCount int64 `protobuf:"varint,7,opt,name=result_count,proto3" json:"result_count,omitempty"` + TrueScotsman bool `protobuf:"varint,8,opt,name=true_scotsman,proto3" json:"true_scotsman,omitempty"` + Score float32 `protobuf:"fixed32,9,opt,name=score,proto3" json:"score,omitempty"` + Key []uint64 `protobuf:"varint,5,rep,name=key" json:"key,omitempty"` + Nested *Nested `protobuf:"bytes,6,opt,name=nested" json:"nested,omitempty"` + Terrain map[int64]*Nested `protobuf:"bytes,10,rep,name=terrain" json:"terrain,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` + Proto2Field *test.NinOptNative `protobuf:"bytes,11,opt,name=proto2_field" json:"proto2_field,omitempty"` + Proto2Value map[int64]*test.NinOptEnum `protobuf:"bytes,13,rep,name=proto2_value" json:"proto2_value,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` +} + +func (m *Message) Reset() { *m = Message{} } +func (*Message) ProtoMessage() {} + +type Nested struct { + Bunny string `protobuf:"bytes,1,opt,name=bunny,proto3" json:"bunny,omitempty"` +} + +func (m *Nested) Reset() { *m = Nested{} } +func (*Nested) ProtoMessage() {} + +type AllMaps struct { + StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key,proto3" protobuf_val:"zigzag32,2,opt,name=value,proto3"` + Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"` + Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=theproto3.MapEnum"` + StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` +} + +func (m *AllMaps) Reset() { *m = AllMaps{} } +func (*AllMaps) ProtoMessage() {} + +type MessageWithMap struct { + NameMapping map[int32]string `protobuf:"bytes,1,rep,name=name_mapping" json:"name_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + MsgMapping map[int64]*FloatingPoint `protobuf:"bytes,2,rep,name=msg_mapping" json:"msg_mapping,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` + ByteMapping map[bool][]byte `protobuf:"bytes,3,rep,name=byte_mapping" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (m *MessageWithMap) Reset() { *m = MessageWithMap{} } +func (*MessageWithMap) ProtoMessage() {} + +type FloatingPoint struct { + F float64 `protobuf:"fixed64,1,opt,name=f,proto3" json:"f,omitempty"` +} + +func (m *FloatingPoint) Reset() { *m = FloatingPoint{} } +func (*FloatingPoint) ProtoMessage() {} + +func init() { + proto.RegisterEnum("theproto3.MapEnum", MapEnum_name, MapEnum_value) + proto.RegisterEnum("theproto3.Message_Humour", Message_Humour_name, Message_Humour_value) +} +func (this *Message) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *Nested) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *AllMaps) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *MessageWithMap) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *FloatingPoint) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func Theproto3Description() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/test/combos/both/thetest.proto"), + Package: func(v string) *string { return &v }("test"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NinRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NidOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }, {Name: func(v string) *string { return &v }("NidNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidRepStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStruct"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinRepStruct"), + }}, + }, {Name: func(v string) *string { return &v }("NidOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomDash"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x64, 0x61, 0x73, 0x68, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NidRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinOptStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinNestedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNativeUnion"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStructUnion"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStructUnion"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Tree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Or"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.OrBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Leaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("OrBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Leaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("StrValue"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepTree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.ADeepBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndDeepBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepLeaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("ADeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndDeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepLeaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Tree"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Nil")}, {Name: func(v string) *string { return &v }("NidOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NidRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + DefaultValue: func(v string) *string { return &v }("C"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + DefaultValue: func(v string) *string { return &v }("E"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Timer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Time1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Time2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Data"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("MyExtendable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("OtherExtenable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("M"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(14), + End: func(v int32) *int32 { return &v }(17), + }, {Start: func(v int32) *int32 { return &v }(10), + End: func(v int32) *int32 { return &v }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("NestedDefinition"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("EnumField"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("NM"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedMessage"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedField1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedMsg"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedField1"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("NestedEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_NESTED"), + Number: func(v int32) *int32 { return &v }(1), + }}, + }}, + }, {Name: func(v string) *string { return &v }("NestedScope"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("true"), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("CustomContainer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("CustomStruct"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptCustom"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x5, 0x46, 0x69, 0x65, 0x6c, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameCustomType"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Ids"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Values"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("CustomNameEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + }, {Name: func(v string) *string { return &v }("NoExtensionsMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0}), 64025: proto.NewExtension([]byte{0xc8, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Unrecognized"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithInner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithInner.Inner"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Inner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithEmbed"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithEmbed.Embedded"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Embedded"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("TheTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }, {Name: func(v string) *string { return &v }("AnotherTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("D"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("E"), + Number: func(v int32) *int32 { return &v }(11), + }}, + Options: &google_protobuf.EnumOptions{XXX_extensions: map[int32]proto.Extension{62001: proto.NewExtension([]byte{0x88, 0xa3, 0x1e, 0x0})}}, + }}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("FieldA"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldB"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldC"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldA1"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldB1"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldC1"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }, {Name: func(v string) *string { return &v }("combos/both/theproto3.proto"), + Package: func(v string) *string { return &v }("theproto3"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto", "github.com/gogo/protobuf/test/combos/both/thetest.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Message"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("hilarity"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".theproto3.Message.Humour"), + }, {Name: func(v string) *string { return &v }("height_in_cm"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("data"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("result_count"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("true_scotsman"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("score"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("nested"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Nested"), + }, {Name: func(v string) *string { return &v }("terrain"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Message.TerrainEntry"), + }, {Name: func(v string) *string { return &v }("proto2_field"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("proto2_value"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Message.Proto2ValueEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("TerrainEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Nested"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Proto2ValueEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Humour"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("UNKNOWN"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("PUNS"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("SLAPSTICK"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("BILL_BAILEY"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("Nested"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("bunny"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("AllMaps"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMap"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToDoubleMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToFloatMap"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToFloatMapEntry"), + }, {Name: func(v string) *string { return &v }("Int32Map"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Int32MapEntry"), + }, {Name: func(v string) *string { return &v }("Int64Map"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Int64MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint32Map"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Uint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint64Map"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Uint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint32Map"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint64Map"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed32Map"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Fixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed32Map"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sfixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed64Map"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Fixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed64Map"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sfixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("BoolMap"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.BoolMapEntry"), + }, {Name: func(v string) *string { return &v }("StringMap"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToBytesMap"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToBytesMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToEnumMap"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToEnumMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToMsgMap"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToMsgMapEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToFloatMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("BoolMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToBytesMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToEnumMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".theproto3.MapEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToMsgMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("MessageWithMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_mapping"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.NameMappingEntry"), + }, {Name: func(v string) *string { return &v }("msg_mapping"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.MsgMappingEntry"), + }, {Name: func(v string) *string { return &v }("byte_mapping"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.ByteMappingEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NameMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("MsgMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("ByteMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("FloatingPoint"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("f"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("MapEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("MA"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("MB"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("MC"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + Syntax: func(v string) *string { return &v }("proto3"), + }}, + } +} +func (x MapEnum) String() string { + s, ok := MapEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x Message_Humour) String() string { + s, ok := Message_Humour_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *Message) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Message) + if !ok { + return fmt.Errorf("that is not of type *Message") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Message but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Messagebut is not nil && this == nil") + } + if this.Name != that1.Name { + return fmt.Errorf("Name this(%v) Not Equal that(%v)", this.Name, that1.Name) + } + if this.Hilarity != that1.Hilarity { + return fmt.Errorf("Hilarity this(%v) Not Equal that(%v)", this.Hilarity, that1.Hilarity) + } + if this.HeightInCm != that1.HeightInCm { + return fmt.Errorf("HeightInCm this(%v) Not Equal that(%v)", this.HeightInCm, that1.HeightInCm) + } + if !bytes.Equal(this.Data, that1.Data) { + return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data) + } + if this.ResultCount != that1.ResultCount { + return fmt.Errorf("ResultCount this(%v) Not Equal that(%v)", this.ResultCount, that1.ResultCount) + } + if this.TrueScotsman != that1.TrueScotsman { + return fmt.Errorf("TrueScotsman this(%v) Not Equal that(%v)", this.TrueScotsman, that1.TrueScotsman) + } + if this.Score != that1.Score { + return fmt.Errorf("Score this(%v) Not Equal that(%v)", this.Score, that1.Score) + } + if len(this.Key) != len(that1.Key) { + return fmt.Errorf("Key this(%v) Not Equal that(%v)", len(this.Key), len(that1.Key)) + } + for i := range this.Key { + if this.Key[i] != that1.Key[i] { + return fmt.Errorf("Key this[%v](%v) Not Equal that[%v](%v)", i, this.Key[i], i, that1.Key[i]) + } + } + if !this.Nested.Equal(that1.Nested) { + return fmt.Errorf("Nested this(%v) Not Equal that(%v)", this.Nested, that1.Nested) + } + if len(this.Terrain) != len(that1.Terrain) { + return fmt.Errorf("Terrain this(%v) Not Equal that(%v)", len(this.Terrain), len(that1.Terrain)) + } + for i := range this.Terrain { + if !this.Terrain[i].Equal(that1.Terrain[i]) { + return fmt.Errorf("Terrain this[%v](%v) Not Equal that[%v](%v)", i, this.Terrain[i], i, that1.Terrain[i]) + } + } + if !this.Proto2Field.Equal(that1.Proto2Field) { + return fmt.Errorf("Proto2Field this(%v) Not Equal that(%v)", this.Proto2Field, that1.Proto2Field) + } + if len(this.Proto2Value) != len(that1.Proto2Value) { + return fmt.Errorf("Proto2Value this(%v) Not Equal that(%v)", len(this.Proto2Value), len(that1.Proto2Value)) + } + for i := range this.Proto2Value { + if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) { + return fmt.Errorf("Proto2Value this[%v](%v) Not Equal that[%v](%v)", i, this.Proto2Value[i], i, that1.Proto2Value[i]) + } + } + return nil +} +func (this *Message) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Message) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Name != that1.Name { + return false + } + if this.Hilarity != that1.Hilarity { + return false + } + if this.HeightInCm != that1.HeightInCm { + return false + } + if !bytes.Equal(this.Data, that1.Data) { + return false + } + if this.ResultCount != that1.ResultCount { + return false + } + if this.TrueScotsman != that1.TrueScotsman { + return false + } + if this.Score != that1.Score { + return false + } + if len(this.Key) != len(that1.Key) { + return false + } + for i := range this.Key { + if this.Key[i] != that1.Key[i] { + return false + } + } + if !this.Nested.Equal(that1.Nested) { + return false + } + if len(this.Terrain) != len(that1.Terrain) { + return false + } + for i := range this.Terrain { + if !this.Terrain[i].Equal(that1.Terrain[i]) { + return false + } + } + if !this.Proto2Field.Equal(that1.Proto2Field) { + return false + } + if len(this.Proto2Value) != len(that1.Proto2Value) { + return false + } + for i := range this.Proto2Value { + if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) { + return false + } + } + return true +} +func (this *Nested) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Nested) + if !ok { + return fmt.Errorf("that is not of type *Nested") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Nested but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Nestedbut is not nil && this == nil") + } + if this.Bunny != that1.Bunny { + return fmt.Errorf("Bunny this(%v) Not Equal that(%v)", this.Bunny, that1.Bunny) + } + return nil +} +func (this *Nested) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Nested) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Bunny != that1.Bunny { + return false + } + return true +} +func (this *AllMaps) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllMaps) + if !ok { + return fmt.Errorf("that is not of type *AllMaps") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllMaps but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllMapsbut is not nil && this == nil") + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap)) + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i]) + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap)) + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i]) + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map)) + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i]) + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map)) + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i]) + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map)) + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i]) + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map)) + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i]) + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map)) + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i]) + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map)) + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i]) + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map)) + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i]) + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map)) + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i]) + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map)) + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i]) + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map)) + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i]) + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap)) + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i]) + } + } + if len(this.StringMap) != len(that1.StringMap) { + return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap)) + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i]) + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap)) + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i]) + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap)) + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i]) + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap)) + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i]) + } + } + return nil +} +func (this *AllMaps) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllMaps) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return false + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return false + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return false + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return false + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return false + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return false + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return false + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return false + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return false + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return false + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return false + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return false + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return false + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return false + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return false + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return false + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return false + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return false + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return false + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return false + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return false + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return false + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return false + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return false + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return false + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return false + } + } + if len(this.StringMap) != len(that1.StringMap) { + return false + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return false + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return false + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return false + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return false + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return false + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return false + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return false + } + } + return true +} +func (this *MessageWithMap) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*MessageWithMap) + if !ok { + return fmt.Errorf("that is not of type *MessageWithMap") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *MessageWithMap but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *MessageWithMapbut is not nil && this == nil") + } + if len(this.NameMapping) != len(that1.NameMapping) { + return fmt.Errorf("NameMapping this(%v) Not Equal that(%v)", len(this.NameMapping), len(that1.NameMapping)) + } + for i := range this.NameMapping { + if this.NameMapping[i] != that1.NameMapping[i] { + return fmt.Errorf("NameMapping this[%v](%v) Not Equal that[%v](%v)", i, this.NameMapping[i], i, that1.NameMapping[i]) + } + } + if len(this.MsgMapping) != len(that1.MsgMapping) { + return fmt.Errorf("MsgMapping this(%v) Not Equal that(%v)", len(this.MsgMapping), len(that1.MsgMapping)) + } + for i := range this.MsgMapping { + if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) { + return fmt.Errorf("MsgMapping this[%v](%v) Not Equal that[%v](%v)", i, this.MsgMapping[i], i, that1.MsgMapping[i]) + } + } + if len(this.ByteMapping) != len(that1.ByteMapping) { + return fmt.Errorf("ByteMapping this(%v) Not Equal that(%v)", len(this.ByteMapping), len(that1.ByteMapping)) + } + for i := range this.ByteMapping { + if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) { + return fmt.Errorf("ByteMapping this[%v](%v) Not Equal that[%v](%v)", i, this.ByteMapping[i], i, that1.ByteMapping[i]) + } + } + return nil +} +func (this *MessageWithMap) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*MessageWithMap) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.NameMapping) != len(that1.NameMapping) { + return false + } + for i := range this.NameMapping { + if this.NameMapping[i] != that1.NameMapping[i] { + return false + } + } + if len(this.MsgMapping) != len(that1.MsgMapping) { + return false + } + for i := range this.MsgMapping { + if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) { + return false + } + } + if len(this.ByteMapping) != len(that1.ByteMapping) { + return false + } + for i := range this.ByteMapping { + if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) { + return false + } + } + return true +} +func (this *FloatingPoint) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return fmt.Errorf("that is not of type *FloatingPoint") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *FloatingPointbut is not nil && this == nil") + } + if this.F != that1.F { + return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F) + } + return nil +} +func (this *FloatingPoint) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.F != that1.F { + return false + } + return true +} + +type MessageFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetName() string + GetHilarity() Message_Humour + GetHeightInCm() uint32 + GetData() []byte + GetResultCount() int64 + GetTrueScotsman() bool + GetScore() float32 + GetKey() []uint64 + GetNested() *Nested + GetTerrain() map[int64]*Nested + GetProto2Field() *test.NinOptNative + GetProto2Value() map[int64]*test.NinOptEnum +} + +func (this *Message) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Message) TestProto() github_com_gogo_protobuf_proto.Message { + return NewMessageFromFace(this) +} + +func (this *Message) GetName() string { + return this.Name +} + +func (this *Message) GetHilarity() Message_Humour { + return this.Hilarity +} + +func (this *Message) GetHeightInCm() uint32 { + return this.HeightInCm +} + +func (this *Message) GetData() []byte { + return this.Data +} + +func (this *Message) GetResultCount() int64 { + return this.ResultCount +} + +func (this *Message) GetTrueScotsman() bool { + return this.TrueScotsman +} + +func (this *Message) GetScore() float32 { + return this.Score +} + +func (this *Message) GetKey() []uint64 { + return this.Key +} + +func (this *Message) GetNested() *Nested { + return this.Nested +} + +func (this *Message) GetTerrain() map[int64]*Nested { + return this.Terrain +} + +func (this *Message) GetProto2Field() *test.NinOptNative { + return this.Proto2Field +} + +func (this *Message) GetProto2Value() map[int64]*test.NinOptEnum { + return this.Proto2Value +} + +func NewMessageFromFace(that MessageFace) *Message { + this := &Message{} + this.Name = that.GetName() + this.Hilarity = that.GetHilarity() + this.HeightInCm = that.GetHeightInCm() + this.Data = that.GetData() + this.ResultCount = that.GetResultCount() + this.TrueScotsman = that.GetTrueScotsman() + this.Score = that.GetScore() + this.Key = that.GetKey() + this.Nested = that.GetNested() + this.Terrain = that.GetTerrain() + this.Proto2Field = that.GetProto2Field() + this.Proto2Value = that.GetProto2Value() + return this +} + +type NestedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetBunny() string +} + +func (this *Nested) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Nested) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedFromFace(this) +} + +func (this *Nested) GetBunny() string { + return this.Bunny +} + +func NewNestedFromFace(that NestedFace) *Nested { + this := &Nested{} + this.Bunny = that.GetBunny() + return this +} + +type AllMapsFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetStringToDoubleMap() map[string]float64 + GetStringToFloatMap() map[string]float32 + GetInt32Map() map[int32]int32 + GetInt64Map() map[int64]int64 + GetUint32Map() map[uint32]uint32 + GetUint64Map() map[uint64]uint64 + GetSint32Map() map[int32]int32 + GetSint64Map() map[int64]int64 + GetFixed32Map() map[uint32]uint32 + GetSfixed32Map() map[int32]int32 + GetFixed64Map() map[uint64]uint64 + GetSfixed64Map() map[int64]int64 + GetBoolMap() map[bool]bool + GetStringMap() map[string]string + GetStringToBytesMap() map[string][]byte + GetStringToEnumMap() map[string]MapEnum + GetStringToMsgMap() map[string]*FloatingPoint +} + +func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAllMapsFromFace(this) +} + +func (this *AllMaps) GetStringToDoubleMap() map[string]float64 { + return this.StringToDoubleMap +} + +func (this *AllMaps) GetStringToFloatMap() map[string]float32 { + return this.StringToFloatMap +} + +func (this *AllMaps) GetInt32Map() map[int32]int32 { + return this.Int32Map +} + +func (this *AllMaps) GetInt64Map() map[int64]int64 { + return this.Int64Map +} + +func (this *AllMaps) GetUint32Map() map[uint32]uint32 { + return this.Uint32Map +} + +func (this *AllMaps) GetUint64Map() map[uint64]uint64 { + return this.Uint64Map +} + +func (this *AllMaps) GetSint32Map() map[int32]int32 { + return this.Sint32Map +} + +func (this *AllMaps) GetSint64Map() map[int64]int64 { + return this.Sint64Map +} + +func (this *AllMaps) GetFixed32Map() map[uint32]uint32 { + return this.Fixed32Map +} + +func (this *AllMaps) GetSfixed32Map() map[int32]int32 { + return this.Sfixed32Map +} + +func (this *AllMaps) GetFixed64Map() map[uint64]uint64 { + return this.Fixed64Map +} + +func (this *AllMaps) GetSfixed64Map() map[int64]int64 { + return this.Sfixed64Map +} + +func (this *AllMaps) GetBoolMap() map[bool]bool { + return this.BoolMap +} + +func (this *AllMaps) GetStringMap() map[string]string { + return this.StringMap +} + +func (this *AllMaps) GetStringToBytesMap() map[string][]byte { + return this.StringToBytesMap +} + +func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum { + return this.StringToEnumMap +} + +func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint { + return this.StringToMsgMap +} + +func NewAllMapsFromFace(that AllMapsFace) *AllMaps { + this := &AllMaps{} + this.StringToDoubleMap = that.GetStringToDoubleMap() + this.StringToFloatMap = that.GetStringToFloatMap() + this.Int32Map = that.GetInt32Map() + this.Int64Map = that.GetInt64Map() + this.Uint32Map = that.GetUint32Map() + this.Uint64Map = that.GetUint64Map() + this.Sint32Map = that.GetSint32Map() + this.Sint64Map = that.GetSint64Map() + this.Fixed32Map = that.GetFixed32Map() + this.Sfixed32Map = that.GetSfixed32Map() + this.Fixed64Map = that.GetFixed64Map() + this.Sfixed64Map = that.GetSfixed64Map() + this.BoolMap = that.GetBoolMap() + this.StringMap = that.GetStringMap() + this.StringToBytesMap = that.GetStringToBytesMap() + this.StringToEnumMap = that.GetStringToEnumMap() + this.StringToMsgMap = that.GetStringToMsgMap() + return this +} + +type MessageWithMapFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNameMapping() map[int32]string + GetMsgMapping() map[int64]*FloatingPoint + GetByteMapping() map[bool][]byte +} + +func (this *MessageWithMap) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *MessageWithMap) TestProto() github_com_gogo_protobuf_proto.Message { + return NewMessageWithMapFromFace(this) +} + +func (this *MessageWithMap) GetNameMapping() map[int32]string { + return this.NameMapping +} + +func (this *MessageWithMap) GetMsgMapping() map[int64]*FloatingPoint { + return this.MsgMapping +} + +func (this *MessageWithMap) GetByteMapping() map[bool][]byte { + return this.ByteMapping +} + +func NewMessageWithMapFromFace(that MessageWithMapFace) *MessageWithMap { + this := &MessageWithMap{} + this.NameMapping = that.GetNameMapping() + this.MsgMapping = that.GetMsgMapping() + this.ByteMapping = that.GetByteMapping() + return this +} + +type FloatingPointFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetF() float64 +} + +func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message { + return NewFloatingPointFromFace(this) +} + +func (this *FloatingPoint) GetF() float64 { + return this.F +} + +func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint { + this := &FloatingPoint{} + this.F = that.GetF() + return this +} + +func (this *Message) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 16) + s = append(s, "&theproto3.Message{") + s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n") + s = append(s, "Hilarity: "+fmt.Sprintf("%#v", this.Hilarity)+",\n") + s = append(s, "HeightInCm: "+fmt.Sprintf("%#v", this.HeightInCm)+",\n") + s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") + s = append(s, "ResultCount: "+fmt.Sprintf("%#v", this.ResultCount)+",\n") + s = append(s, "TrueScotsman: "+fmt.Sprintf("%#v", this.TrueScotsman)+",\n") + s = append(s, "Score: "+fmt.Sprintf("%#v", this.Score)+",\n") + s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n") + if this.Nested != nil { + s = append(s, "Nested: "+fmt.Sprintf("%#v", this.Nested)+",\n") + } + keysForTerrain := make([]int64, 0, len(this.Terrain)) + for k := range this.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + mapStringForTerrain := "map[int64]*Nested{" + for _, k := range keysForTerrain { + mapStringForTerrain += fmt.Sprintf("%#v: %#v,", k, this.Terrain[k]) + } + mapStringForTerrain += "}" + if this.Terrain != nil { + s = append(s, "Terrain: "+mapStringForTerrain+",\n") + } + if this.Proto2Field != nil { + s = append(s, "Proto2Field: "+fmt.Sprintf("%#v", this.Proto2Field)+",\n") + } + keysForProto2Value := make([]int64, 0, len(this.Proto2Value)) + for k := range this.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + mapStringForProto2Value := "map[int64]*test.NinOptEnum{" + for _, k := range keysForProto2Value { + mapStringForProto2Value += fmt.Sprintf("%#v: %#v,", k, this.Proto2Value[k]) + } + mapStringForProto2Value += "}" + if this.Proto2Value != nil { + s = append(s, "Proto2Value: "+mapStringForProto2Value+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Nested) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&theproto3.Nested{") + s = append(s, "Bunny: "+fmt.Sprintf("%#v", this.Bunny)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllMaps) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 21) + s = append(s, "&theproto3.AllMaps{") + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + if this.StringToDoubleMap != nil { + s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n") + } + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + if this.StringToFloatMap != nil { + s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n") + } + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + if this.Int32Map != nil { + s = append(s, "Int32Map: "+mapStringForInt32Map+",\n") + } + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + if this.Int64Map != nil { + s = append(s, "Int64Map: "+mapStringForInt64Map+",\n") + } + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + if this.Uint32Map != nil { + s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n") + } + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + if this.Uint64Map != nil { + s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n") + } + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + if this.Sint32Map != nil { + s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n") + } + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + if this.Sint64Map != nil { + s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n") + } + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + if this.Fixed32Map != nil { + s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n") + } + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + if this.Sfixed32Map != nil { + s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n") + } + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + if this.Fixed64Map != nil { + s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n") + } + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + if this.Sfixed64Map != nil { + s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n") + } + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + if this.BoolMap != nil { + s = append(s, "BoolMap: "+mapStringForBoolMap+",\n") + } + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + if this.StringMap != nil { + s = append(s, "StringMap: "+mapStringForStringMap+",\n") + } + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + if this.StringToBytesMap != nil { + s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n") + } + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + if this.StringToEnumMap != nil { + s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n") + } + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + if this.StringToMsgMap != nil { + s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MessageWithMap) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&theproto3.MessageWithMap{") + keysForNameMapping := make([]int32, 0, len(this.NameMapping)) + for k := range this.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + mapStringForNameMapping := "map[int32]string{" + for _, k := range keysForNameMapping { + mapStringForNameMapping += fmt.Sprintf("%#v: %#v,", k, this.NameMapping[k]) + } + mapStringForNameMapping += "}" + if this.NameMapping != nil { + s = append(s, "NameMapping: "+mapStringForNameMapping+",\n") + } + keysForMsgMapping := make([]int64, 0, len(this.MsgMapping)) + for k := range this.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + mapStringForMsgMapping := "map[int64]*FloatingPoint{" + for _, k := range keysForMsgMapping { + mapStringForMsgMapping += fmt.Sprintf("%#v: %#v,", k, this.MsgMapping[k]) + } + mapStringForMsgMapping += "}" + if this.MsgMapping != nil { + s = append(s, "MsgMapping: "+mapStringForMsgMapping+",\n") + } + keysForByteMapping := make([]bool, 0, len(this.ByteMapping)) + for k := range this.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + mapStringForByteMapping := "map[bool][]byte{" + for _, k := range keysForByteMapping { + mapStringForByteMapping += fmt.Sprintf("%#v: %#v,", k, this.ByteMapping[k]) + } + mapStringForByteMapping += "}" + if this.ByteMapping != nil { + s = append(s, "ByteMapping: "+mapStringForByteMapping+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FloatingPoint) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&theproto3.FloatingPoint{") + s = append(s, "F: "+fmt.Sprintf("%#v", this.F)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringTheproto3(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringTheproto3(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *Message) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Message) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(m.Name))) + i += copy(data[i:], m.Name) + } + if m.Hilarity != 0 { + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(m.Hilarity)) + } + if m.HeightInCm != 0 { + data[i] = 0x18 + i++ + i = encodeVarintTheproto3(data, i, uint64(m.HeightInCm)) + } + if m.Data != nil { + if len(m.Data) > 0 { + data[i] = 0x22 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(m.Data))) + i += copy(data[i:], m.Data) + } + } + if len(m.Key) > 0 { + for _, num := range m.Key { + data[i] = 0x28 + i++ + i = encodeVarintTheproto3(data, i, uint64(num)) + } + } + if m.Nested != nil { + data[i] = 0x32 + i++ + i = encodeVarintTheproto3(data, i, uint64(m.Nested.Size())) + n1, err := m.Nested.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n1 + } + if m.ResultCount != 0 { + data[i] = 0x38 + i++ + i = encodeVarintTheproto3(data, i, uint64(m.ResultCount)) + } + if m.TrueScotsman { + data[i] = 0x40 + i++ + if m.TrueScotsman { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Score != 0 { + data[i] = 0x4d + i++ + i = encodeFixed32Theproto3(data, i, uint32(math.Float32bits(m.Score))) + } + if len(m.Terrain) > 0 { + keysForTerrain := make([]int64, 0, len(m.Terrain)) + for k := range m.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + for _, k := range keysForTerrain { + data[i] = 0x52 + i++ + v := m.Terrain[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + msgSize + sovTheproto3(uint64(msgSize)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(v.Size())) + n2, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + } + } + if m.Proto2Field != nil { + data[i] = 0x5a + i++ + i = encodeVarintTheproto3(data, i, uint64(m.Proto2Field.Size())) + n3, err := m.Proto2Field.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n3 + } + if len(m.Proto2Value) > 0 { + keysForProto2Value := make([]int64, 0, len(m.Proto2Value)) + for k := range m.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + for _, k := range keysForProto2Value { + data[i] = 0x6a + i++ + v := m.Proto2Value[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + msgSize + sovTheproto3(uint64(msgSize)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(v.Size())) + n4, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n4 + } + } + return i, nil +} + +func (m *Nested) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Nested) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Bunny) > 0 { + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(m.Bunny))) + i += copy(data[i:], m.Bunny) + } + return i, nil +} + +func (m *AllMaps) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AllMaps) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + keysForStringToDoubleMap := make([]string, 0, len(m.StringToDoubleMap)) + for k := range m.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + for _, k := range keysForStringToDoubleMap { + data[i] = 0xa + i++ + v := m.StringToDoubleMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x11 + i++ + i = encodeFixed64Theproto3(data, i, uint64(math.Float64bits(v))) + } + } + if len(m.StringToFloatMap) > 0 { + keysForStringToFloatMap := make([]string, 0, len(m.StringToFloatMap)) + for k := range m.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + for _, k := range keysForStringToFloatMap { + data[i] = 0x12 + i++ + v := m.StringToFloatMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x15 + i++ + i = encodeFixed32Theproto3(data, i, uint32(math.Float32bits(v))) + } + } + if len(m.Int32Map) > 0 { + keysForInt32Map := make([]int32, 0, len(m.Int32Map)) + for k := range m.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + for _, k := range keysForInt32Map { + data[i] = 0x1a + i++ + v := m.Int32Map[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.Int64Map) > 0 { + keysForInt64Map := make([]int64, 0, len(m.Int64Map)) + for k := range m.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + for _, k := range keysForInt64Map { + data[i] = 0x22 + i++ + v := m.Int64Map[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.Uint32Map) > 0 { + keysForUint32Map := make([]uint32, 0, len(m.Uint32Map)) + for k := range m.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + for _, k := range keysForUint32Map { + data[i] = 0x2a + i++ + v := m.Uint32Map[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.Uint64Map) > 0 { + keysForUint64Map := make([]uint64, 0, len(m.Uint64Map)) + for k := range m.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + for _, k := range keysForUint64Map { + data[i] = 0x32 + i++ + v := m.Uint64Map[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.Sint32Map) > 0 { + keysForSint32Map := make([]int32, 0, len(m.Sint32Map)) + for k := range m.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + for _, k := range keysForSint32Map { + data[i] = 0x3a + i++ + v := m.Sint32Map[k] + mapSize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint32(k)<<1)^uint32((k>>31)))) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint32(v)<<1)^uint32((v>>31)))) + } + } + if len(m.Sint64Map) > 0 { + keysForSint64Map := make([]int64, 0, len(m.Sint64Map)) + for k := range m.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + for _, k := range keysForSint64Map { + data[i] = 0x42 + i++ + v := m.Sint64Map[k] + mapSize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint64(k)<<1)^uint64((k>>63)))) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint64(v)<<1)^uint64((v>>63)))) + } + } + if len(m.Fixed32Map) > 0 { + keysForFixed32Map := make([]uint32, 0, len(m.Fixed32Map)) + for k := range m.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + for _, k := range keysForFixed32Map { + data[i] = 0x4a + i++ + v := m.Fixed32Map[k] + mapSize := 1 + 4 + 1 + 4 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xd + i++ + i = encodeFixed32Theproto3(data, i, uint32(k)) + data[i] = 0x15 + i++ + i = encodeFixed32Theproto3(data, i, uint32(v)) + } + } + if len(m.Sfixed32Map) > 0 { + keysForSfixed32Map := make([]int32, 0, len(m.Sfixed32Map)) + for k := range m.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + for _, k := range keysForSfixed32Map { + data[i] = 0x52 + i++ + v := m.Sfixed32Map[k] + mapSize := 1 + 4 + 1 + 4 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xd + i++ + i = encodeFixed32Theproto3(data, i, uint32(k)) + data[i] = 0x15 + i++ + i = encodeFixed32Theproto3(data, i, uint32(v)) + } + } + if len(m.Fixed64Map) > 0 { + keysForFixed64Map := make([]uint64, 0, len(m.Fixed64Map)) + for k := range m.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + for _, k := range keysForFixed64Map { + data[i] = 0x5a + i++ + v := m.Fixed64Map[k] + mapSize := 1 + 8 + 1 + 8 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x9 + i++ + i = encodeFixed64Theproto3(data, i, uint64(k)) + data[i] = 0x11 + i++ + i = encodeFixed64Theproto3(data, i, uint64(v)) + } + } + if len(m.Sfixed64Map) > 0 { + keysForSfixed64Map := make([]int64, 0, len(m.Sfixed64Map)) + for k := range m.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + for _, k := range keysForSfixed64Map { + data[i] = 0x62 + i++ + v := m.Sfixed64Map[k] + mapSize := 1 + 8 + 1 + 8 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x9 + i++ + i = encodeFixed64Theproto3(data, i, uint64(k)) + data[i] = 0x11 + i++ + i = encodeFixed64Theproto3(data, i, uint64(v)) + } + } + if len(m.BoolMap) > 0 { + keysForBoolMap := make([]bool, 0, len(m.BoolMap)) + for k := range m.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + for _, k := range keysForBoolMap { + data[i] = 0x6a + i++ + v := m.BoolMap[k] + mapSize := 1 + 1 + 1 + 1 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + if k { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x10 + i++ + if v { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.StringMap) > 0 { + keysForStringMap := make([]string, 0, len(m.StringMap)) + for k := range m.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + for _, k := range keysForStringMap { + data[i] = 0x72 + i++ + v := m.StringMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.StringToBytesMap) > 0 { + keysForStringToBytesMap := make([]string, 0, len(m.StringToBytesMap)) + for k := range m.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + for _, k := range keysForStringToBytesMap { + data[i] = 0x7a + i++ + v := m.StringToBytesMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.StringToEnumMap) > 0 { + keysForStringToEnumMap := make([]string, 0, len(m.StringToEnumMap)) + for k := range m.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + for _, k := range keysForStringToEnumMap { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + v := m.StringToEnumMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.StringToMsgMap) > 0 { + keysForStringToMsgMap := make([]string, 0, len(m.StringToMsgMap)) + for k := range m.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + for _, k := range keysForStringToMsgMap { + data[i] = 0x8a + i++ + data[i] = 0x1 + i++ + v := m.StringToMsgMap[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + msgSize + sovTheproto3(uint64(msgSize)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(v.Size())) + n5, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n5 + } + } + return i, nil +} + +func (m *MessageWithMap) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *MessageWithMap) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.NameMapping) > 0 { + keysForNameMapping := make([]int32, 0, len(m.NameMapping)) + for k := range m.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + for _, k := range keysForNameMapping { + data[i] = 0xa + i++ + v := m.NameMapping[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + len(v) + sovTheproto3(uint64(len(v))) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.MsgMapping) > 0 { + keysForMsgMapping := make([]int64, 0, len(m.MsgMapping)) + for k := range m.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + for _, k := range keysForMsgMapping { + data[i] = 0x12 + i++ + v := m.MsgMapping[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + sozTheproto3(uint64(k)) + 1 + msgSize + sovTheproto3(uint64(msgSize)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint64(k)<<1)^uint64((k>>63)))) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(v.Size())) + n6, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n6 + } + } + if len(m.ByteMapping) > 0 { + keysForByteMapping := make([]bool, 0, len(m.ByteMapping)) + for k := range m.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + for _, k := range keysForByteMapping { + data[i] = 0x1a + i++ + v := m.ByteMapping[k] + mapSize := 1 + 1 + 1 + len(v) + sovTheproto3(uint64(len(v))) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + if k { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + return i, nil +} + +func (m *FloatingPoint) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *FloatingPoint) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.F != 0 { + data[i] = 0x9 + i++ + i = encodeFixed64Theproto3(data, i, uint64(math.Float64bits(m.F))) + } + return i, nil +} + +func encodeFixed64Theproto3(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Theproto3(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintTheproto3(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedMessage(r randyTheproto3, easy bool) *Message { + this := &Message{} + this.Name = randStringTheproto3(r) + this.Hilarity = Message_Humour([]int32{0, 1, 2, 3}[r.Intn(4)]) + this.HeightInCm = uint32(r.Uint32()) + v1 := r.Intn(100) + this.Data = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Data[i] = byte(r.Intn(256)) + } + v2 := r.Intn(100) + this.Key = make([]uint64, v2) + for i := 0; i < v2; i++ { + this.Key[i] = uint64(uint64(r.Uint32())) + } + if r.Intn(10) != 0 { + this.Nested = NewPopulatedNested(r, easy) + } + this.ResultCount = int64(r.Int63()) + if r.Intn(2) == 0 { + this.ResultCount *= -1 + } + this.TrueScotsman = bool(bool(r.Intn(2) == 0)) + this.Score = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Score *= -1 + } + if r.Intn(10) != 0 { + v3 := r.Intn(10) + this.Terrain = make(map[int64]*Nested) + for i := 0; i < v3; i++ { + this.Terrain[int64(r.Int63())] = NewPopulatedNested(r, easy) + } + } + if r.Intn(10) != 0 { + this.Proto2Field = test.NewPopulatedNinOptNative(r, easy) + } + if r.Intn(10) != 0 { + v4 := r.Intn(10) + this.Proto2Value = make(map[int64]*test.NinOptEnum) + for i := 0; i < v4; i++ { + this.Proto2Value[int64(r.Int63())] = test.NewPopulatedNinOptEnum(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedNested(r randyTheproto3, easy bool) *Nested { + this := &Nested{} + this.Bunny = randStringTheproto3(r) + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedAllMaps(r randyTheproto3, easy bool) *AllMaps { + this := &AllMaps{} + if r.Intn(10) != 0 { + v5 := r.Intn(10) + this.StringToDoubleMap = make(map[string]float64) + for i := 0; i < v5; i++ { + v6 := randStringTheproto3(r) + this.StringToDoubleMap[v6] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.StringToDoubleMap[v6] *= -1 + } + } + } + if r.Intn(10) != 0 { + v7 := r.Intn(10) + this.StringToFloatMap = make(map[string]float32) + for i := 0; i < v7; i++ { + v8 := randStringTheproto3(r) + this.StringToFloatMap[v8] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.StringToFloatMap[v8] *= -1 + } + } + } + if r.Intn(10) != 0 { + v9 := r.Intn(10) + this.Int32Map = make(map[int32]int32) + for i := 0; i < v9; i++ { + v10 := int32(r.Int31()) + this.Int32Map[v10] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Int32Map[v10] *= -1 + } + } + } + if r.Intn(10) != 0 { + v11 := r.Intn(10) + this.Int64Map = make(map[int64]int64) + for i := 0; i < v11; i++ { + v12 := int64(r.Int63()) + this.Int64Map[v12] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Int64Map[v12] *= -1 + } + } + } + if r.Intn(10) != 0 { + v13 := r.Intn(10) + this.Uint32Map = make(map[uint32]uint32) + for i := 0; i < v13; i++ { + v14 := uint32(r.Uint32()) + this.Uint32Map[v14] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v15 := r.Intn(10) + this.Uint64Map = make(map[uint64]uint64) + for i := 0; i < v15; i++ { + v16 := uint64(uint64(r.Uint32())) + this.Uint64Map[v16] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v17 := r.Intn(10) + this.Sint32Map = make(map[int32]int32) + for i := 0; i < v17; i++ { + v18 := int32(r.Int31()) + this.Sint32Map[v18] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sint32Map[v18] *= -1 + } + } + } + if r.Intn(10) != 0 { + v19 := r.Intn(10) + this.Sint64Map = make(map[int64]int64) + for i := 0; i < v19; i++ { + v20 := int64(r.Int63()) + this.Sint64Map[v20] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sint64Map[v20] *= -1 + } + } + } + if r.Intn(10) != 0 { + v21 := r.Intn(10) + this.Fixed32Map = make(map[uint32]uint32) + for i := 0; i < v21; i++ { + v22 := uint32(r.Uint32()) + this.Fixed32Map[v22] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v23 := r.Intn(10) + this.Sfixed32Map = make(map[int32]int32) + for i := 0; i < v23; i++ { + v24 := int32(r.Int31()) + this.Sfixed32Map[v24] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sfixed32Map[v24] *= -1 + } + } + } + if r.Intn(10) != 0 { + v25 := r.Intn(10) + this.Fixed64Map = make(map[uint64]uint64) + for i := 0; i < v25; i++ { + v26 := uint64(uint64(r.Uint32())) + this.Fixed64Map[v26] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v27 := r.Intn(10) + this.Sfixed64Map = make(map[int64]int64) + for i := 0; i < v27; i++ { + v28 := int64(r.Int63()) + this.Sfixed64Map[v28] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sfixed64Map[v28] *= -1 + } + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(10) + this.BoolMap = make(map[bool]bool) + for i := 0; i < v29; i++ { + v30 := bool(bool(r.Intn(2) == 0)) + this.BoolMap[v30] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v31 := r.Intn(10) + this.StringMap = make(map[string]string) + for i := 0; i < v31; i++ { + this.StringMap[randStringTheproto3(r)] = randStringTheproto3(r) + } + } + if r.Intn(10) != 0 { + v32 := r.Intn(10) + this.StringToBytesMap = make(map[string][]byte) + for i := 0; i < v32; i++ { + v33 := r.Intn(100) + v34 := randStringTheproto3(r) + this.StringToBytesMap[v34] = make([]byte, v33) + for i := 0; i < v33; i++ { + this.StringToBytesMap[v34][i] = byte(r.Intn(256)) + } + } + } + if r.Intn(10) != 0 { + v35 := r.Intn(10) + this.StringToEnumMap = make(map[string]MapEnum) + for i := 0; i < v35; i++ { + this.StringToEnumMap[randStringTheproto3(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if r.Intn(10) != 0 { + v36 := r.Intn(10) + this.StringToMsgMap = make(map[string]*FloatingPoint) + for i := 0; i < v36; i++ { + this.StringToMsgMap[randStringTheproto3(r)] = NewPopulatedFloatingPoint(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedMessageWithMap(r randyTheproto3, easy bool) *MessageWithMap { + this := &MessageWithMap{} + if r.Intn(10) != 0 { + v37 := r.Intn(10) + this.NameMapping = make(map[int32]string) + for i := 0; i < v37; i++ { + this.NameMapping[int32(r.Int31())] = randStringTheproto3(r) + } + } + if r.Intn(10) != 0 { + v38 := r.Intn(10) + this.MsgMapping = make(map[int64]*FloatingPoint) + for i := 0; i < v38; i++ { + this.MsgMapping[int64(r.Int63())] = NewPopulatedFloatingPoint(r, easy) + } + } + if r.Intn(10) != 0 { + v39 := r.Intn(10) + this.ByteMapping = make(map[bool][]byte) + for i := 0; i < v39; i++ { + v40 := r.Intn(100) + v41 := bool(bool(r.Intn(2) == 0)) + this.ByteMapping[v41] = make([]byte, v40) + for i := 0; i < v40; i++ { + this.ByteMapping[v41][i] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedFloatingPoint(r randyTheproto3, easy bool) *FloatingPoint { + this := &FloatingPoint{} + this.F = float64(r.Float64()) + if r.Intn(2) == 0 { + this.F *= -1 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +type randyTheproto3 interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneTheproto3(r randyTheproto3) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringTheproto3(r randyTheproto3) string { + v42 := r.Intn(100) + tmps := make([]rune, v42) + for i := 0; i < v42; i++ { + tmps[i] = randUTF8RuneTheproto3(r) + } + return string(tmps) +} +func randUnrecognizedTheproto3(r randyTheproto3, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldTheproto3(data, r, fieldNumber, wire) + } + return data +} +func randFieldTheproto3(data []byte, r randyTheproto3, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + v43 := r.Int63() + if r.Intn(2) == 0 { + v43 *= -1 + } + data = encodeVarintPopulateTheproto3(data, uint64(v43)) + case 1: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateTheproto3(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateTheproto3(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Message) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + if m.Hilarity != 0 { + n += 1 + sovTheproto3(uint64(m.Hilarity)) + } + if m.HeightInCm != 0 { + n += 1 + sovTheproto3(uint64(m.HeightInCm)) + } + if m.Data != nil { + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + } + if len(m.Key) > 0 { + for _, e := range m.Key { + n += 1 + sovTheproto3(uint64(e)) + } + } + if m.Nested != nil { + l = m.Nested.Size() + n += 1 + l + sovTheproto3(uint64(l)) + } + if m.ResultCount != 0 { + n += 1 + sovTheproto3(uint64(m.ResultCount)) + } + if m.TrueScotsman { + n += 2 + } + if m.Score != 0 { + n += 5 + } + if len(m.Terrain) > 0 { + for k, v := range m.Terrain { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if m.Proto2Field != nil { + l = m.Proto2Field.Size() + n += 1 + l + sovTheproto3(uint64(l)) + } + if len(m.Proto2Value) > 0 { + for k, v := range m.Proto2Value { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *Nested) Size() (n int) { + var l int + _ = l + l = len(m.Bunny) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + return n +} + +func (m *AllMaps) Size() (n int) { + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + for k, v := range m.StringToDoubleMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToFloatMap) > 0 { + for k, v := range m.StringToFloatMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Int32Map) > 0 { + for k, v := range m.Int32Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Int64Map) > 0 { + for k, v := range m.Int64Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Uint32Map) > 0 { + for k, v := range m.Uint32Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Uint64Map) > 0 { + for k, v := range m.Uint64Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sint32Map) > 0 { + for k, v := range m.Sint32Map { + _ = k + _ = v + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sint64Map) > 0 { + for k, v := range m.Sint64Map { + _ = k + _ = v + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Fixed32Map) > 0 { + for k, v := range m.Fixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sfixed32Map) > 0 { + for k, v := range m.Sfixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Fixed64Map) > 0 { + for k, v := range m.Fixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sfixed64Map) > 0 { + for k, v := range m.Sfixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.BoolMap) > 0 { + for k, v := range m.BoolMap { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + 1 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringMap) > 0 { + for k, v := range m.StringMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToBytesMap) > 0 { + for k, v := range m.StringToBytesMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToEnumMap) > 0 { + for k, v := range m.StringToEnumMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToMsgMap) > 0 { + for k, v := range m.StringToMsgMap { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *MessageWithMap) Size() (n int) { + var l int + _ = l + if len(m.NameMapping) > 0 { + for k, v := range m.NameMapping { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.MsgMapping) > 0 { + for k, v := range m.MsgMapping { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.ByteMapping) > 0 { + for k, v := range m.ByteMapping { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *FloatingPoint) Size() (n int) { + var l int + _ = l + if m.F != 0 { + n += 9 + } + return n +} + +func sovTheproto3(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozTheproto3(x uint64) (n int) { + return sovTheproto3(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Message) String() string { + if this == nil { + return "nil" + } + keysForTerrain := make([]int64, 0, len(this.Terrain)) + for k := range this.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + mapStringForTerrain := "map[int64]*Nested{" + for _, k := range keysForTerrain { + mapStringForTerrain += fmt.Sprintf("%v: %v,", k, this.Terrain[k]) + } + mapStringForTerrain += "}" + keysForProto2Value := make([]int64, 0, len(this.Proto2Value)) + for k := range this.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + mapStringForProto2Value := "map[int64]*test.NinOptEnum{" + for _, k := range keysForProto2Value { + mapStringForProto2Value += fmt.Sprintf("%v: %v,", k, this.Proto2Value[k]) + } + mapStringForProto2Value += "}" + s := strings.Join([]string{`&Message{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Hilarity:` + fmt.Sprintf("%v", this.Hilarity) + `,`, + `HeightInCm:` + fmt.Sprintf("%v", this.HeightInCm) + `,`, + `Data:` + fmt.Sprintf("%v", this.Data) + `,`, + `Key:` + fmt.Sprintf("%v", this.Key) + `,`, + `Nested:` + strings.Replace(fmt.Sprintf("%v", this.Nested), "Nested", "Nested", 1) + `,`, + `ResultCount:` + fmt.Sprintf("%v", this.ResultCount) + `,`, + `TrueScotsman:` + fmt.Sprintf("%v", this.TrueScotsman) + `,`, + `Score:` + fmt.Sprintf("%v", this.Score) + `,`, + `Terrain:` + mapStringForTerrain + `,`, + `Proto2Field:` + strings.Replace(fmt.Sprintf("%v", this.Proto2Field), "NinOptNative", "test.NinOptNative", 1) + `,`, + `Proto2Value:` + mapStringForProto2Value + `,`, + `}`, + }, "") + return s +} +func (this *Nested) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Nested{`, + `Bunny:` + fmt.Sprintf("%v", this.Bunny) + `,`, + `}`, + }, "") + return s +} +func (this *AllMaps) String() string { + if this == nil { + return "nil" + } + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + s := strings.Join([]string{`&AllMaps{`, + `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`, + `StringToFloatMap:` + mapStringForStringToFloatMap + `,`, + `Int32Map:` + mapStringForInt32Map + `,`, + `Int64Map:` + mapStringForInt64Map + `,`, + `Uint32Map:` + mapStringForUint32Map + `,`, + `Uint64Map:` + mapStringForUint64Map + `,`, + `Sint32Map:` + mapStringForSint32Map + `,`, + `Sint64Map:` + mapStringForSint64Map + `,`, + `Fixed32Map:` + mapStringForFixed32Map + `,`, + `Sfixed32Map:` + mapStringForSfixed32Map + `,`, + `Fixed64Map:` + mapStringForFixed64Map + `,`, + `Sfixed64Map:` + mapStringForSfixed64Map + `,`, + `BoolMap:` + mapStringForBoolMap + `,`, + `StringMap:` + mapStringForStringMap + `,`, + `StringToBytesMap:` + mapStringForStringToBytesMap + `,`, + `StringToEnumMap:` + mapStringForStringToEnumMap + `,`, + `StringToMsgMap:` + mapStringForStringToMsgMap + `,`, + `}`, + }, "") + return s +} +func (this *MessageWithMap) String() string { + if this == nil { + return "nil" + } + keysForNameMapping := make([]int32, 0, len(this.NameMapping)) + for k := range this.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + mapStringForNameMapping := "map[int32]string{" + for _, k := range keysForNameMapping { + mapStringForNameMapping += fmt.Sprintf("%v: %v,", k, this.NameMapping[k]) + } + mapStringForNameMapping += "}" + keysForMsgMapping := make([]int64, 0, len(this.MsgMapping)) + for k := range this.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + mapStringForMsgMapping := "map[int64]*FloatingPoint{" + for _, k := range keysForMsgMapping { + mapStringForMsgMapping += fmt.Sprintf("%v: %v,", k, this.MsgMapping[k]) + } + mapStringForMsgMapping += "}" + keysForByteMapping := make([]bool, 0, len(this.ByteMapping)) + for k := range this.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + mapStringForByteMapping := "map[bool][]byte{" + for _, k := range keysForByteMapping { + mapStringForByteMapping += fmt.Sprintf("%v: %v,", k, this.ByteMapping[k]) + } + mapStringForByteMapping += "}" + s := strings.Join([]string{`&MessageWithMap{`, + `NameMapping:` + mapStringForNameMapping + `,`, + `MsgMapping:` + mapStringForMsgMapping + `,`, + `ByteMapping:` + mapStringForByteMapping + `,`, + `}`, + }, "") + return s +} +func (this *FloatingPoint) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FloatingPoint{`, + `F:` + fmt.Sprintf("%v", this.F) + `,`, + `}`, + }, "") + return s +} +func valueToStringTheproto3(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Message) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Message: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Message: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Hilarity", wireType) + } + m.Hilarity = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Hilarity |= (Message_Humour(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field HeightInCm", wireType) + } + m.HeightInCm = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.HeightInCm |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Key = append(m.Key, v) + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Nested", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Nested == nil { + m.Nested = &Nested{} + } + if err := m.Nested.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ResultCount", wireType) + } + m.ResultCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ResultCount |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TrueScotsman", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TrueScotsman = bool(v != 0) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Score", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Score = float32(math.Float32frombits(v)) + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Terrain", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3 + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3 + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &Nested{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.Terrain == nil { + m.Terrain = make(map[int64]*Nested) + } + m.Terrain[mapkey] = mapvalue + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proto2Field", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Proto2Field == nil { + m.Proto2Field = &test.NinOptNative{} + } + if err := m.Proto2Field.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proto2Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3 + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3 + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &test.NinOptEnum{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.Proto2Value == nil { + m.Proto2Value = make(map[int64]*test.NinOptEnum) + } + m.Proto2Value[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTheproto3(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Nested) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Nested: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Nested: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Bunny", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Bunny = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTheproto3(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AllMaps) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AllMaps: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AllMaps: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvaluetemp = uint64(data[iNdEx-8]) + mapvaluetemp |= uint64(data[iNdEx-7]) << 8 + mapvaluetemp |= uint64(data[iNdEx-6]) << 16 + mapvaluetemp |= uint64(data[iNdEx-5]) << 24 + mapvaluetemp |= uint64(data[iNdEx-4]) << 32 + mapvaluetemp |= uint64(data[iNdEx-3]) << 40 + mapvaluetemp |= uint64(data[iNdEx-2]) << 48 + mapvaluetemp |= uint64(data[iNdEx-1]) << 56 + mapvalue := math.Float64frombits(mapvaluetemp) + if m.StringToDoubleMap == nil { + m.StringToDoubleMap = make(map[string]float64) + } + m.StringToDoubleMap[mapkey] = mapvalue + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvaluetemp = uint32(data[iNdEx-4]) + mapvaluetemp |= uint32(data[iNdEx-3]) << 8 + mapvaluetemp |= uint32(data[iNdEx-2]) << 16 + mapvaluetemp |= uint32(data[iNdEx-1]) << 24 + mapvalue := math.Float32frombits(mapvaluetemp) + if m.StringToFloatMap == nil { + m.StringToFloatMap = make(map[string]float32) + } + m.StringToFloatMap[mapkey] = mapvalue + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Int32Map == nil { + m.Int32Map = make(map[int32]int32) + } + m.Int32Map[mapkey] = mapvalue + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Int64Map == nil { + m.Int64Map = make(map[int64]int64) + } + m.Int64Map[mapkey] = mapvalue + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Uint32Map == nil { + m.Uint32Map = make(map[uint32]uint32) + } + m.Uint32Map[mapkey] = mapvalue + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Uint64Map == nil { + m.Uint64Map = make(map[uint64]uint64) + } + m.Uint64Map[mapkey] = mapvalue + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31)) + mapkey := int32(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31)) + mapvalue := int32(mapvaluetemp) + if m.Sint32Map == nil { + m.Sint32Map = make(map[int32]int32) + } + m.Sint32Map[mapkey] = mapvalue + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63) + mapkey := int64(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63) + mapvalue := int64(mapvaluetemp) + if m.Sint64Map == nil { + m.Sint64Map = make(map[int64]int64) + } + m.Sint64Map[mapkey] = mapvalue + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapkey = uint32(data[iNdEx-4]) + mapkey |= uint32(data[iNdEx-3]) << 8 + mapkey |= uint32(data[iNdEx-2]) << 16 + mapkey |= uint32(data[iNdEx-1]) << 24 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvalue = uint32(data[iNdEx-4]) + mapvalue |= uint32(data[iNdEx-3]) << 8 + mapvalue |= uint32(data[iNdEx-2]) << 16 + mapvalue |= uint32(data[iNdEx-1]) << 24 + if m.Fixed32Map == nil { + m.Fixed32Map = make(map[uint32]uint32) + } + m.Fixed32Map[mapkey] = mapvalue + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapkey = int32(data[iNdEx-4]) + mapkey |= int32(data[iNdEx-3]) << 8 + mapkey |= int32(data[iNdEx-2]) << 16 + mapkey |= int32(data[iNdEx-1]) << 24 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvalue = int32(data[iNdEx-4]) + mapvalue |= int32(data[iNdEx-3]) << 8 + mapvalue |= int32(data[iNdEx-2]) << 16 + mapvalue |= int32(data[iNdEx-1]) << 24 + if m.Sfixed32Map == nil { + m.Sfixed32Map = make(map[int32]int32) + } + m.Sfixed32Map[mapkey] = mapvalue + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapkey = uint64(data[iNdEx-8]) + mapkey |= uint64(data[iNdEx-7]) << 8 + mapkey |= uint64(data[iNdEx-6]) << 16 + mapkey |= uint64(data[iNdEx-5]) << 24 + mapkey |= uint64(data[iNdEx-4]) << 32 + mapkey |= uint64(data[iNdEx-3]) << 40 + mapkey |= uint64(data[iNdEx-2]) << 48 + mapkey |= uint64(data[iNdEx-1]) << 56 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvalue = uint64(data[iNdEx-8]) + mapvalue |= uint64(data[iNdEx-7]) << 8 + mapvalue |= uint64(data[iNdEx-6]) << 16 + mapvalue |= uint64(data[iNdEx-5]) << 24 + mapvalue |= uint64(data[iNdEx-4]) << 32 + mapvalue |= uint64(data[iNdEx-3]) << 40 + mapvalue |= uint64(data[iNdEx-2]) << 48 + mapvalue |= uint64(data[iNdEx-1]) << 56 + if m.Fixed64Map == nil { + m.Fixed64Map = make(map[uint64]uint64) + } + m.Fixed64Map[mapkey] = mapvalue + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapkey = int64(data[iNdEx-8]) + mapkey |= int64(data[iNdEx-7]) << 8 + mapkey |= int64(data[iNdEx-6]) << 16 + mapkey |= int64(data[iNdEx-5]) << 24 + mapkey |= int64(data[iNdEx-4]) << 32 + mapkey |= int64(data[iNdEx-3]) << 40 + mapkey |= int64(data[iNdEx-2]) << 48 + mapkey |= int64(data[iNdEx-1]) << 56 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvalue = int64(data[iNdEx-8]) + mapvalue |= int64(data[iNdEx-7]) << 8 + mapvalue |= int64(data[iNdEx-6]) << 16 + mapvalue |= int64(data[iNdEx-5]) << 24 + mapvalue |= int64(data[iNdEx-4]) << 32 + mapvalue |= int64(data[iNdEx-3]) << 40 + mapvalue |= int64(data[iNdEx-2]) << 48 + mapvalue |= int64(data[iNdEx-1]) << 56 + if m.Sfixed64Map == nil { + m.Sfixed64Map = make(map[int64]int64) + } + m.Sfixed64Map[mapkey] = mapvalue + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkey := bool(mapkeytemp != 0) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvalue := bool(mapvaluetemp != 0) + if m.BoolMap == nil { + m.BoolMap = make(map[bool]bool) + } + m.BoolMap[mapkey] = mapvalue + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthTheproto3 + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue := string(data[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + if m.StringMap == nil { + m.StringMap = make(map[string]string) + } + m.StringMap[mapkey] = mapvalue + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapbyteLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthTheproto3 + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := make([]byte, mapbyteLen) + copy(mapvalue, data[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + if m.StringToBytesMap == nil { + m.StringToBytesMap = make(map[string][]byte) + } + m.StringToBytesMap[mapkey] = mapvalue + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue MapEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (MapEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.StringToEnumMap == nil { + m.StringToEnumMap = make(map[string]MapEnum) + } + m.StringToEnumMap[mapkey] = mapvalue + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3 + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3 + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &FloatingPoint{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.StringToMsgMap == nil { + m.StringToMsgMap = make(map[string]*FloatingPoint) + } + m.StringToMsgMap[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTheproto3(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MessageWithMap) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MessageWithMap: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MessageWithMap: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NameMapping", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthTheproto3 + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue := string(data[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + if m.NameMapping == nil { + m.NameMapping = make(map[int32]string) + } + m.NameMapping[mapkey] = mapvalue + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MsgMapping", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63) + mapkey := int64(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3 + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3 + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &FloatingPoint{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.MsgMapping == nil { + m.MsgMapping = make(map[int64]*FloatingPoint) + } + m.MsgMapping[mapkey] = mapvalue + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ByteMapping", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkey := bool(mapkeytemp != 0) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapbyteLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthTheproto3 + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := make([]byte, mapbyteLen) + copy(mapvalue, data[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + if m.ByteMapping == nil { + m.ByteMapping = make(map[bool][]byte) + } + m.ByteMapping[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTheproto3(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FloatingPoint) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FloatingPoint: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FloatingPoint: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field F", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.F = float64(math.Float64frombits(v)) + default: + iNdEx = preIndex + skippy, err := skipTheproto3(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTheproto3(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthTheproto3 + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipTheproto3(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthTheproto3 = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTheproto3 = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/both/theproto3.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/both/theproto3.proto new file mode 100644 index 0000000000000000000000000000000000000000..5c080ded5c5fc6e66ae372449d0c747380dd84e7 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/both/theproto3.proto @@ -0,0 +1,129 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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 theproto3; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +import "github.com/gogo/protobuf/test/combos/both/thetest.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Message { + enum Humour { + UNKNOWN = 0; + PUNS = 1; + SLAPSTICK = 2; + BILL_BAILEY = 3; + } + + string name = 1; + Humour hilarity = 2; + uint32 height_in_cm = 3; + bytes data = 4; + int64 result_count = 7; + bool true_scotsman = 8; + float score = 9; + + repeated uint64 key = 5; + Nested nested = 6; + + map terrain = 10; + test.NinOptNative proto2_field = 11; + map proto2_value = 13; +} + +message Nested { + string bunny = 1; +} + +enum MapEnum { + MA = 0; + MB = 1; + MC = 2; +} + +message AllMaps { + map StringToDoubleMap = 1; + map StringToFloatMap = 2; + map Int32Map = 3; + map Int64Map = 4; + map Uint32Map = 5; + map Uint64Map = 6; + map Sint32Map = 7; + map Sint64Map = 8; + map Fixed32Map = 9; + map Sfixed32Map = 10; + map Fixed64Map = 11; + map Sfixed64Map = 12; + map BoolMap = 13; + map StringMap = 14; + map StringToBytesMap = 15; + map StringToEnumMap = 16; + map StringToMsgMap = 17; +} + +message MessageWithMap { + map name_mapping = 1; + map msg_mapping = 2; + map byte_mapping = 3; +} + +message FloatingPoint { + double f = 1; +} \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/both/theproto3pb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/both/theproto3pb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..78ccc65f3c073a433e9e40103ecd2eafd7ee6c9d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/both/theproto3pb_test.go @@ -0,0 +1,1232 @@ +// Code generated by protoc-gen-gogo. +// source: combos/both/theproto3.proto +// DO NOT EDIT! + +/* +Package theproto3 is a generated protocol buffer package. + +It is generated from these files: + combos/both/theproto3.proto + +It has these top-level messages: + Message + Nested + AllMaps + MessageWithMap + FloatingPoint +*/ +package theproto3 + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" +// discarding unused import test "github.com/gogo/protobuf/test/combos/both" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestMessageProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestMessageMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkMessageProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Message, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMessageProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessage(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Message{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nested, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNested(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNested(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Nested{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAllMapsMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAllMapsProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMaps(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AllMaps{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageWithMapProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestMessageWithMapMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkMessageWithMapProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MessageWithMap, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMessageWithMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMessageWithMapProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessageWithMap(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &MessageWithMap{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestFloatingPointMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkFloatingPointProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedFloatingPoint(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &FloatingPoint{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllMapsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMessageWithMapJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestFloatingPointJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMessageProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Message{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Message{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageWithMapProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageWithMapProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTheproto3Description(t *testing.T) { + Theproto3Description() +} +func TestMessageVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllMapsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMessageWithMapVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestFloatingPointVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMessageFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAllMapsFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestMessageWithMapFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestFloatingPointFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestMessageGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllMapsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMessageWithMapGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestFloatingPointGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMessageSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMessageSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Message, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nested, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNested(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAllMapsSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageWithMapSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMessageWithMapSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MessageWithMap, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMessageWithMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkFloatingPointSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllMapsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestMessageWithMapStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestFloatingPointStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/marshaler/nilmaps_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/marshaler/nilmaps_test.go new file mode 100644 index 0000000000000000000000000000000000000000..1b05c72b2c453fe78cac35296c395d0dc5951bc8 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/marshaler/nilmaps_test.go @@ -0,0 +1,39 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 theproto3 + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "testing" +) + +func TestNilMaps(t *testing.T) { + m := &AllMaps{StringToMsgMap: map[string]*FloatingPoint{"a": nil}} + if _, err := proto.Marshal(m); err == nil { + t.Fatalf("expected error") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/marshaler/theproto3.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/marshaler/theproto3.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..a0b9d45e7c936e3d9db87ac67471e84277b787ad --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/marshaler/theproto3.pb.go @@ -0,0 +1,8295 @@ +// Code generated by protoc-gen-gogo. +// source: combos/marshaler/theproto3.proto +// DO NOT EDIT! + +/* + Package theproto3 is a generated protocol buffer package. + + It is generated from these files: + combos/marshaler/theproto3.proto + + It has these top-level messages: + Message + Nested + AllMaps + MessageWithMap + FloatingPoint +*/ +package theproto3 + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" +import test "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" +import github_com_gogo_protobuf_sortkeys "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/sortkeys" + +import errors "errors" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type MapEnum int32 + +const ( + MA MapEnum = 0 + MB MapEnum = 1 + MC MapEnum = 2 +) + +var MapEnum_name = map[int32]string{ + 0: "MA", + 1: "MB", + 2: "MC", +} +var MapEnum_value = map[string]int32{ + "MA": 0, + "MB": 1, + "MC": 2, +} + +type Message_Humour int32 + +const ( + UNKNOWN Message_Humour = 0 + PUNS Message_Humour = 1 + SLAPSTICK Message_Humour = 2 + BILL_BAILEY Message_Humour = 3 +) + +var Message_Humour_name = map[int32]string{ + 0: "UNKNOWN", + 1: "PUNS", + 2: "SLAPSTICK", + 3: "BILL_BAILEY", +} +var Message_Humour_value = map[string]int32{ + "UNKNOWN": 0, + "PUNS": 1, + "SLAPSTICK": 2, + "BILL_BAILEY": 3, +} + +type Message struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Hilarity Message_Humour `protobuf:"varint,2,opt,name=hilarity,proto3,enum=theproto3.Message_Humour" json:"hilarity,omitempty"` + HeightInCm uint32 `protobuf:"varint,3,opt,name=height_in_cm,proto3" json:"height_in_cm,omitempty"` + Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` + ResultCount int64 `protobuf:"varint,7,opt,name=result_count,proto3" json:"result_count,omitempty"` + TrueScotsman bool `protobuf:"varint,8,opt,name=true_scotsman,proto3" json:"true_scotsman,omitempty"` + Score float32 `protobuf:"fixed32,9,opt,name=score,proto3" json:"score,omitempty"` + Key []uint64 `protobuf:"varint,5,rep,name=key" json:"key,omitempty"` + Nested *Nested `protobuf:"bytes,6,opt,name=nested" json:"nested,omitempty"` + Terrain map[int64]*Nested `protobuf:"bytes,10,rep,name=terrain" json:"terrain,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` + Proto2Field *test.NinOptNative `protobuf:"bytes,11,opt,name=proto2_field" json:"proto2_field,omitempty"` + Proto2Value map[int64]*test.NinOptEnum `protobuf:"bytes,13,rep,name=proto2_value" json:"proto2_value,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` +} + +func (m *Message) Reset() { *m = Message{} } +func (*Message) ProtoMessage() {} + +type Nested struct { + Bunny string `protobuf:"bytes,1,opt,name=bunny,proto3" json:"bunny,omitempty"` +} + +func (m *Nested) Reset() { *m = Nested{} } +func (*Nested) ProtoMessage() {} + +type AllMaps struct { + StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key,proto3" protobuf_val:"zigzag32,2,opt,name=value,proto3"` + Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"` + Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=theproto3.MapEnum"` + StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` +} + +func (m *AllMaps) Reset() { *m = AllMaps{} } +func (*AllMaps) ProtoMessage() {} + +type MessageWithMap struct { + NameMapping map[int32]string `protobuf:"bytes,1,rep,name=name_mapping" json:"name_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + MsgMapping map[int64]*FloatingPoint `protobuf:"bytes,2,rep,name=msg_mapping" json:"msg_mapping,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` + ByteMapping map[bool][]byte `protobuf:"bytes,3,rep,name=byte_mapping" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (m *MessageWithMap) Reset() { *m = MessageWithMap{} } +func (*MessageWithMap) ProtoMessage() {} + +type FloatingPoint struct { + F float64 `protobuf:"fixed64,1,opt,name=f,proto3" json:"f,omitempty"` +} + +func (m *FloatingPoint) Reset() { *m = FloatingPoint{} } +func (*FloatingPoint) ProtoMessage() {} + +func init() { + proto.RegisterEnum("theproto3.MapEnum", MapEnum_name, MapEnum_value) + proto.RegisterEnum("theproto3.Message_Humour", Message_Humour_name, Message_Humour_value) +} +func (this *Message) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *Nested) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *AllMaps) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *MessageWithMap) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *FloatingPoint) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func Theproto3Description() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/test/combos/both/thetest.proto"), + Package: func(v string) *string { return &v }("test"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NinRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NidOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }, {Name: func(v string) *string { return &v }("NidNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidRepStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStruct"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinRepStruct"), + }}, + }, {Name: func(v string) *string { return &v }("NidOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomDash"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x64, 0x61, 0x73, 0x68, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NidRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinOptStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinNestedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNativeUnion"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStructUnion"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStructUnion"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Tree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Or"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.OrBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Leaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("OrBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Leaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("StrValue"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepTree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.ADeepBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndDeepBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepLeaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("ADeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndDeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepLeaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Tree"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Nil")}, {Name: func(v string) *string { return &v }("NidOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NidRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + DefaultValue: func(v string) *string { return &v }("C"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + DefaultValue: func(v string) *string { return &v }("E"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Timer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Time1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Time2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Data"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("MyExtendable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("OtherExtenable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("M"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(14), + End: func(v int32) *int32 { return &v }(17), + }, {Start: func(v int32) *int32 { return &v }(10), + End: func(v int32) *int32 { return &v }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("NestedDefinition"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("EnumField"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("NM"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedMessage"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedField1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedMsg"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedField1"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("NestedEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_NESTED"), + Number: func(v int32) *int32 { return &v }(1), + }}, + }}, + }, {Name: func(v string) *string { return &v }("NestedScope"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("true"), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("CustomContainer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("CustomStruct"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptCustom"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x5, 0x46, 0x69, 0x65, 0x6c, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameCustomType"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Ids"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Values"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("CustomNameEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + }, {Name: func(v string) *string { return &v }("NoExtensionsMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0}), 64025: proto.NewExtension([]byte{0xc8, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Unrecognized"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithInner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithInner.Inner"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Inner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithEmbed"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithEmbed.Embedded"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Embedded"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("TheTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }, {Name: func(v string) *string { return &v }("AnotherTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("D"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("E"), + Number: func(v int32) *int32 { return &v }(11), + }}, + Options: &google_protobuf.EnumOptions{XXX_extensions: map[int32]proto.Extension{62001: proto.NewExtension([]byte{0x88, 0xa3, 0x1e, 0x0})}}, + }}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("FieldA"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldB"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldC"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldA1"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldB1"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldC1"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }, {Name: func(v string) *string { return &v }("combos/marshaler/theproto3.proto"), + Package: func(v string) *string { return &v }("theproto3"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto", "github.com/gogo/protobuf/test/combos/both/thetest.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Message"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("hilarity"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".theproto3.Message.Humour"), + }, {Name: func(v string) *string { return &v }("height_in_cm"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("data"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("result_count"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("true_scotsman"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("score"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("nested"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Nested"), + }, {Name: func(v string) *string { return &v }("terrain"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Message.TerrainEntry"), + }, {Name: func(v string) *string { return &v }("proto2_field"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("proto2_value"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Message.Proto2ValueEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("TerrainEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Nested"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Proto2ValueEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Humour"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("UNKNOWN"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("PUNS"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("SLAPSTICK"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("BILL_BAILEY"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("Nested"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("bunny"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("AllMaps"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMap"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToDoubleMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToFloatMap"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToFloatMapEntry"), + }, {Name: func(v string) *string { return &v }("Int32Map"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Int32MapEntry"), + }, {Name: func(v string) *string { return &v }("Int64Map"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Int64MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint32Map"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Uint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint64Map"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Uint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint32Map"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint64Map"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed32Map"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Fixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed32Map"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sfixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed64Map"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Fixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed64Map"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sfixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("BoolMap"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.BoolMapEntry"), + }, {Name: func(v string) *string { return &v }("StringMap"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToBytesMap"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToBytesMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToEnumMap"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToEnumMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToMsgMap"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToMsgMapEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToFloatMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("BoolMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToBytesMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToEnumMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".theproto3.MapEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToMsgMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("MessageWithMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_mapping"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.NameMappingEntry"), + }, {Name: func(v string) *string { return &v }("msg_mapping"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.MsgMappingEntry"), + }, {Name: func(v string) *string { return &v }("byte_mapping"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.ByteMappingEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NameMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("MsgMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("ByteMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("FloatingPoint"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("f"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("MapEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("MA"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("MB"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("MC"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + Syntax: func(v string) *string { return &v }("proto3"), + }}, + } +} +func (x MapEnum) String() string { + s, ok := MapEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x Message_Humour) String() string { + s, ok := Message_Humour_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *Message) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Message) + if !ok { + return fmt.Errorf("that is not of type *Message") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Message but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Messagebut is not nil && this == nil") + } + if this.Name != that1.Name { + return fmt.Errorf("Name this(%v) Not Equal that(%v)", this.Name, that1.Name) + } + if this.Hilarity != that1.Hilarity { + return fmt.Errorf("Hilarity this(%v) Not Equal that(%v)", this.Hilarity, that1.Hilarity) + } + if this.HeightInCm != that1.HeightInCm { + return fmt.Errorf("HeightInCm this(%v) Not Equal that(%v)", this.HeightInCm, that1.HeightInCm) + } + if !bytes.Equal(this.Data, that1.Data) { + return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data) + } + if this.ResultCount != that1.ResultCount { + return fmt.Errorf("ResultCount this(%v) Not Equal that(%v)", this.ResultCount, that1.ResultCount) + } + if this.TrueScotsman != that1.TrueScotsman { + return fmt.Errorf("TrueScotsman this(%v) Not Equal that(%v)", this.TrueScotsman, that1.TrueScotsman) + } + if this.Score != that1.Score { + return fmt.Errorf("Score this(%v) Not Equal that(%v)", this.Score, that1.Score) + } + if len(this.Key) != len(that1.Key) { + return fmt.Errorf("Key this(%v) Not Equal that(%v)", len(this.Key), len(that1.Key)) + } + for i := range this.Key { + if this.Key[i] != that1.Key[i] { + return fmt.Errorf("Key this[%v](%v) Not Equal that[%v](%v)", i, this.Key[i], i, that1.Key[i]) + } + } + if !this.Nested.Equal(that1.Nested) { + return fmt.Errorf("Nested this(%v) Not Equal that(%v)", this.Nested, that1.Nested) + } + if len(this.Terrain) != len(that1.Terrain) { + return fmt.Errorf("Terrain this(%v) Not Equal that(%v)", len(this.Terrain), len(that1.Terrain)) + } + for i := range this.Terrain { + if !this.Terrain[i].Equal(that1.Terrain[i]) { + return fmt.Errorf("Terrain this[%v](%v) Not Equal that[%v](%v)", i, this.Terrain[i], i, that1.Terrain[i]) + } + } + if !this.Proto2Field.Equal(that1.Proto2Field) { + return fmt.Errorf("Proto2Field this(%v) Not Equal that(%v)", this.Proto2Field, that1.Proto2Field) + } + if len(this.Proto2Value) != len(that1.Proto2Value) { + return fmt.Errorf("Proto2Value this(%v) Not Equal that(%v)", len(this.Proto2Value), len(that1.Proto2Value)) + } + for i := range this.Proto2Value { + if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) { + return fmt.Errorf("Proto2Value this[%v](%v) Not Equal that[%v](%v)", i, this.Proto2Value[i], i, that1.Proto2Value[i]) + } + } + return nil +} +func (this *Message) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Message) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Name != that1.Name { + return false + } + if this.Hilarity != that1.Hilarity { + return false + } + if this.HeightInCm != that1.HeightInCm { + return false + } + if !bytes.Equal(this.Data, that1.Data) { + return false + } + if this.ResultCount != that1.ResultCount { + return false + } + if this.TrueScotsman != that1.TrueScotsman { + return false + } + if this.Score != that1.Score { + return false + } + if len(this.Key) != len(that1.Key) { + return false + } + for i := range this.Key { + if this.Key[i] != that1.Key[i] { + return false + } + } + if !this.Nested.Equal(that1.Nested) { + return false + } + if len(this.Terrain) != len(that1.Terrain) { + return false + } + for i := range this.Terrain { + if !this.Terrain[i].Equal(that1.Terrain[i]) { + return false + } + } + if !this.Proto2Field.Equal(that1.Proto2Field) { + return false + } + if len(this.Proto2Value) != len(that1.Proto2Value) { + return false + } + for i := range this.Proto2Value { + if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) { + return false + } + } + return true +} +func (this *Nested) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Nested) + if !ok { + return fmt.Errorf("that is not of type *Nested") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Nested but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Nestedbut is not nil && this == nil") + } + if this.Bunny != that1.Bunny { + return fmt.Errorf("Bunny this(%v) Not Equal that(%v)", this.Bunny, that1.Bunny) + } + return nil +} +func (this *Nested) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Nested) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Bunny != that1.Bunny { + return false + } + return true +} +func (this *AllMaps) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllMaps) + if !ok { + return fmt.Errorf("that is not of type *AllMaps") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllMaps but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllMapsbut is not nil && this == nil") + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap)) + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i]) + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap)) + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i]) + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map)) + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i]) + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map)) + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i]) + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map)) + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i]) + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map)) + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i]) + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map)) + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i]) + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map)) + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i]) + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map)) + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i]) + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map)) + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i]) + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map)) + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i]) + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map)) + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i]) + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap)) + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i]) + } + } + if len(this.StringMap) != len(that1.StringMap) { + return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap)) + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i]) + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap)) + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i]) + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap)) + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i]) + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap)) + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i]) + } + } + return nil +} +func (this *AllMaps) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllMaps) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return false + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return false + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return false + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return false + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return false + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return false + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return false + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return false + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return false + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return false + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return false + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return false + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return false + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return false + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return false + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return false + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return false + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return false + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return false + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return false + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return false + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return false + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return false + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return false + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return false + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return false + } + } + if len(this.StringMap) != len(that1.StringMap) { + return false + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return false + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return false + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return false + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return false + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return false + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return false + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return false + } + } + return true +} +func (this *MessageWithMap) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*MessageWithMap) + if !ok { + return fmt.Errorf("that is not of type *MessageWithMap") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *MessageWithMap but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *MessageWithMapbut is not nil && this == nil") + } + if len(this.NameMapping) != len(that1.NameMapping) { + return fmt.Errorf("NameMapping this(%v) Not Equal that(%v)", len(this.NameMapping), len(that1.NameMapping)) + } + for i := range this.NameMapping { + if this.NameMapping[i] != that1.NameMapping[i] { + return fmt.Errorf("NameMapping this[%v](%v) Not Equal that[%v](%v)", i, this.NameMapping[i], i, that1.NameMapping[i]) + } + } + if len(this.MsgMapping) != len(that1.MsgMapping) { + return fmt.Errorf("MsgMapping this(%v) Not Equal that(%v)", len(this.MsgMapping), len(that1.MsgMapping)) + } + for i := range this.MsgMapping { + if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) { + return fmt.Errorf("MsgMapping this[%v](%v) Not Equal that[%v](%v)", i, this.MsgMapping[i], i, that1.MsgMapping[i]) + } + } + if len(this.ByteMapping) != len(that1.ByteMapping) { + return fmt.Errorf("ByteMapping this(%v) Not Equal that(%v)", len(this.ByteMapping), len(that1.ByteMapping)) + } + for i := range this.ByteMapping { + if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) { + return fmt.Errorf("ByteMapping this[%v](%v) Not Equal that[%v](%v)", i, this.ByteMapping[i], i, that1.ByteMapping[i]) + } + } + return nil +} +func (this *MessageWithMap) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*MessageWithMap) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.NameMapping) != len(that1.NameMapping) { + return false + } + for i := range this.NameMapping { + if this.NameMapping[i] != that1.NameMapping[i] { + return false + } + } + if len(this.MsgMapping) != len(that1.MsgMapping) { + return false + } + for i := range this.MsgMapping { + if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) { + return false + } + } + if len(this.ByteMapping) != len(that1.ByteMapping) { + return false + } + for i := range this.ByteMapping { + if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) { + return false + } + } + return true +} +func (this *FloatingPoint) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return fmt.Errorf("that is not of type *FloatingPoint") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *FloatingPointbut is not nil && this == nil") + } + if this.F != that1.F { + return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F) + } + return nil +} +func (this *FloatingPoint) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.F != that1.F { + return false + } + return true +} + +type MessageFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetName() string + GetHilarity() Message_Humour + GetHeightInCm() uint32 + GetData() []byte + GetResultCount() int64 + GetTrueScotsman() bool + GetScore() float32 + GetKey() []uint64 + GetNested() *Nested + GetTerrain() map[int64]*Nested + GetProto2Field() *test.NinOptNative + GetProto2Value() map[int64]*test.NinOptEnum +} + +func (this *Message) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Message) TestProto() github_com_gogo_protobuf_proto.Message { + return NewMessageFromFace(this) +} + +func (this *Message) GetName() string { + return this.Name +} + +func (this *Message) GetHilarity() Message_Humour { + return this.Hilarity +} + +func (this *Message) GetHeightInCm() uint32 { + return this.HeightInCm +} + +func (this *Message) GetData() []byte { + return this.Data +} + +func (this *Message) GetResultCount() int64 { + return this.ResultCount +} + +func (this *Message) GetTrueScotsman() bool { + return this.TrueScotsman +} + +func (this *Message) GetScore() float32 { + return this.Score +} + +func (this *Message) GetKey() []uint64 { + return this.Key +} + +func (this *Message) GetNested() *Nested { + return this.Nested +} + +func (this *Message) GetTerrain() map[int64]*Nested { + return this.Terrain +} + +func (this *Message) GetProto2Field() *test.NinOptNative { + return this.Proto2Field +} + +func (this *Message) GetProto2Value() map[int64]*test.NinOptEnum { + return this.Proto2Value +} + +func NewMessageFromFace(that MessageFace) *Message { + this := &Message{} + this.Name = that.GetName() + this.Hilarity = that.GetHilarity() + this.HeightInCm = that.GetHeightInCm() + this.Data = that.GetData() + this.ResultCount = that.GetResultCount() + this.TrueScotsman = that.GetTrueScotsman() + this.Score = that.GetScore() + this.Key = that.GetKey() + this.Nested = that.GetNested() + this.Terrain = that.GetTerrain() + this.Proto2Field = that.GetProto2Field() + this.Proto2Value = that.GetProto2Value() + return this +} + +type NestedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetBunny() string +} + +func (this *Nested) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Nested) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedFromFace(this) +} + +func (this *Nested) GetBunny() string { + return this.Bunny +} + +func NewNestedFromFace(that NestedFace) *Nested { + this := &Nested{} + this.Bunny = that.GetBunny() + return this +} + +type AllMapsFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetStringToDoubleMap() map[string]float64 + GetStringToFloatMap() map[string]float32 + GetInt32Map() map[int32]int32 + GetInt64Map() map[int64]int64 + GetUint32Map() map[uint32]uint32 + GetUint64Map() map[uint64]uint64 + GetSint32Map() map[int32]int32 + GetSint64Map() map[int64]int64 + GetFixed32Map() map[uint32]uint32 + GetSfixed32Map() map[int32]int32 + GetFixed64Map() map[uint64]uint64 + GetSfixed64Map() map[int64]int64 + GetBoolMap() map[bool]bool + GetStringMap() map[string]string + GetStringToBytesMap() map[string][]byte + GetStringToEnumMap() map[string]MapEnum + GetStringToMsgMap() map[string]*FloatingPoint +} + +func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAllMapsFromFace(this) +} + +func (this *AllMaps) GetStringToDoubleMap() map[string]float64 { + return this.StringToDoubleMap +} + +func (this *AllMaps) GetStringToFloatMap() map[string]float32 { + return this.StringToFloatMap +} + +func (this *AllMaps) GetInt32Map() map[int32]int32 { + return this.Int32Map +} + +func (this *AllMaps) GetInt64Map() map[int64]int64 { + return this.Int64Map +} + +func (this *AllMaps) GetUint32Map() map[uint32]uint32 { + return this.Uint32Map +} + +func (this *AllMaps) GetUint64Map() map[uint64]uint64 { + return this.Uint64Map +} + +func (this *AllMaps) GetSint32Map() map[int32]int32 { + return this.Sint32Map +} + +func (this *AllMaps) GetSint64Map() map[int64]int64 { + return this.Sint64Map +} + +func (this *AllMaps) GetFixed32Map() map[uint32]uint32 { + return this.Fixed32Map +} + +func (this *AllMaps) GetSfixed32Map() map[int32]int32 { + return this.Sfixed32Map +} + +func (this *AllMaps) GetFixed64Map() map[uint64]uint64 { + return this.Fixed64Map +} + +func (this *AllMaps) GetSfixed64Map() map[int64]int64 { + return this.Sfixed64Map +} + +func (this *AllMaps) GetBoolMap() map[bool]bool { + return this.BoolMap +} + +func (this *AllMaps) GetStringMap() map[string]string { + return this.StringMap +} + +func (this *AllMaps) GetStringToBytesMap() map[string][]byte { + return this.StringToBytesMap +} + +func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum { + return this.StringToEnumMap +} + +func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint { + return this.StringToMsgMap +} + +func NewAllMapsFromFace(that AllMapsFace) *AllMaps { + this := &AllMaps{} + this.StringToDoubleMap = that.GetStringToDoubleMap() + this.StringToFloatMap = that.GetStringToFloatMap() + this.Int32Map = that.GetInt32Map() + this.Int64Map = that.GetInt64Map() + this.Uint32Map = that.GetUint32Map() + this.Uint64Map = that.GetUint64Map() + this.Sint32Map = that.GetSint32Map() + this.Sint64Map = that.GetSint64Map() + this.Fixed32Map = that.GetFixed32Map() + this.Sfixed32Map = that.GetSfixed32Map() + this.Fixed64Map = that.GetFixed64Map() + this.Sfixed64Map = that.GetSfixed64Map() + this.BoolMap = that.GetBoolMap() + this.StringMap = that.GetStringMap() + this.StringToBytesMap = that.GetStringToBytesMap() + this.StringToEnumMap = that.GetStringToEnumMap() + this.StringToMsgMap = that.GetStringToMsgMap() + return this +} + +type MessageWithMapFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNameMapping() map[int32]string + GetMsgMapping() map[int64]*FloatingPoint + GetByteMapping() map[bool][]byte +} + +func (this *MessageWithMap) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *MessageWithMap) TestProto() github_com_gogo_protobuf_proto.Message { + return NewMessageWithMapFromFace(this) +} + +func (this *MessageWithMap) GetNameMapping() map[int32]string { + return this.NameMapping +} + +func (this *MessageWithMap) GetMsgMapping() map[int64]*FloatingPoint { + return this.MsgMapping +} + +func (this *MessageWithMap) GetByteMapping() map[bool][]byte { + return this.ByteMapping +} + +func NewMessageWithMapFromFace(that MessageWithMapFace) *MessageWithMap { + this := &MessageWithMap{} + this.NameMapping = that.GetNameMapping() + this.MsgMapping = that.GetMsgMapping() + this.ByteMapping = that.GetByteMapping() + return this +} + +type FloatingPointFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetF() float64 +} + +func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message { + return NewFloatingPointFromFace(this) +} + +func (this *FloatingPoint) GetF() float64 { + return this.F +} + +func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint { + this := &FloatingPoint{} + this.F = that.GetF() + return this +} + +func (this *Message) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 16) + s = append(s, "&theproto3.Message{") + s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n") + s = append(s, "Hilarity: "+fmt.Sprintf("%#v", this.Hilarity)+",\n") + s = append(s, "HeightInCm: "+fmt.Sprintf("%#v", this.HeightInCm)+",\n") + s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") + s = append(s, "ResultCount: "+fmt.Sprintf("%#v", this.ResultCount)+",\n") + s = append(s, "TrueScotsman: "+fmt.Sprintf("%#v", this.TrueScotsman)+",\n") + s = append(s, "Score: "+fmt.Sprintf("%#v", this.Score)+",\n") + s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n") + if this.Nested != nil { + s = append(s, "Nested: "+fmt.Sprintf("%#v", this.Nested)+",\n") + } + keysForTerrain := make([]int64, 0, len(this.Terrain)) + for k := range this.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + mapStringForTerrain := "map[int64]*Nested{" + for _, k := range keysForTerrain { + mapStringForTerrain += fmt.Sprintf("%#v: %#v,", k, this.Terrain[k]) + } + mapStringForTerrain += "}" + if this.Terrain != nil { + s = append(s, "Terrain: "+mapStringForTerrain+",\n") + } + if this.Proto2Field != nil { + s = append(s, "Proto2Field: "+fmt.Sprintf("%#v", this.Proto2Field)+",\n") + } + keysForProto2Value := make([]int64, 0, len(this.Proto2Value)) + for k := range this.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + mapStringForProto2Value := "map[int64]*test.NinOptEnum{" + for _, k := range keysForProto2Value { + mapStringForProto2Value += fmt.Sprintf("%#v: %#v,", k, this.Proto2Value[k]) + } + mapStringForProto2Value += "}" + if this.Proto2Value != nil { + s = append(s, "Proto2Value: "+mapStringForProto2Value+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Nested) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&theproto3.Nested{") + s = append(s, "Bunny: "+fmt.Sprintf("%#v", this.Bunny)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllMaps) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 21) + s = append(s, "&theproto3.AllMaps{") + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + if this.StringToDoubleMap != nil { + s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n") + } + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + if this.StringToFloatMap != nil { + s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n") + } + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + if this.Int32Map != nil { + s = append(s, "Int32Map: "+mapStringForInt32Map+",\n") + } + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + if this.Int64Map != nil { + s = append(s, "Int64Map: "+mapStringForInt64Map+",\n") + } + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + if this.Uint32Map != nil { + s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n") + } + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + if this.Uint64Map != nil { + s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n") + } + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + if this.Sint32Map != nil { + s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n") + } + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + if this.Sint64Map != nil { + s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n") + } + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + if this.Fixed32Map != nil { + s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n") + } + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + if this.Sfixed32Map != nil { + s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n") + } + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + if this.Fixed64Map != nil { + s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n") + } + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + if this.Sfixed64Map != nil { + s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n") + } + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + if this.BoolMap != nil { + s = append(s, "BoolMap: "+mapStringForBoolMap+",\n") + } + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + if this.StringMap != nil { + s = append(s, "StringMap: "+mapStringForStringMap+",\n") + } + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + if this.StringToBytesMap != nil { + s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n") + } + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + if this.StringToEnumMap != nil { + s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n") + } + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + if this.StringToMsgMap != nil { + s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MessageWithMap) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&theproto3.MessageWithMap{") + keysForNameMapping := make([]int32, 0, len(this.NameMapping)) + for k := range this.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + mapStringForNameMapping := "map[int32]string{" + for _, k := range keysForNameMapping { + mapStringForNameMapping += fmt.Sprintf("%#v: %#v,", k, this.NameMapping[k]) + } + mapStringForNameMapping += "}" + if this.NameMapping != nil { + s = append(s, "NameMapping: "+mapStringForNameMapping+",\n") + } + keysForMsgMapping := make([]int64, 0, len(this.MsgMapping)) + for k := range this.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + mapStringForMsgMapping := "map[int64]*FloatingPoint{" + for _, k := range keysForMsgMapping { + mapStringForMsgMapping += fmt.Sprintf("%#v: %#v,", k, this.MsgMapping[k]) + } + mapStringForMsgMapping += "}" + if this.MsgMapping != nil { + s = append(s, "MsgMapping: "+mapStringForMsgMapping+",\n") + } + keysForByteMapping := make([]bool, 0, len(this.ByteMapping)) + for k := range this.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + mapStringForByteMapping := "map[bool][]byte{" + for _, k := range keysForByteMapping { + mapStringForByteMapping += fmt.Sprintf("%#v: %#v,", k, this.ByteMapping[k]) + } + mapStringForByteMapping += "}" + if this.ByteMapping != nil { + s = append(s, "ByteMapping: "+mapStringForByteMapping+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FloatingPoint) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&theproto3.FloatingPoint{") + s = append(s, "F: "+fmt.Sprintf("%#v", this.F)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringTheproto3(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringTheproto3(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *Message) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Message) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(m.Name))) + i += copy(data[i:], m.Name) + } + if m.Hilarity != 0 { + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(m.Hilarity)) + } + if m.HeightInCm != 0 { + data[i] = 0x18 + i++ + i = encodeVarintTheproto3(data, i, uint64(m.HeightInCm)) + } + if m.Data != nil { + if len(m.Data) > 0 { + data[i] = 0x22 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(m.Data))) + i += copy(data[i:], m.Data) + } + } + if len(m.Key) > 0 { + for _, num := range m.Key { + data[i] = 0x28 + i++ + i = encodeVarintTheproto3(data, i, uint64(num)) + } + } + if m.Nested != nil { + data[i] = 0x32 + i++ + i = encodeVarintTheproto3(data, i, uint64(m.Nested.Size())) + n1, err := m.Nested.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n1 + } + if m.ResultCount != 0 { + data[i] = 0x38 + i++ + i = encodeVarintTheproto3(data, i, uint64(m.ResultCount)) + } + if m.TrueScotsman { + data[i] = 0x40 + i++ + if m.TrueScotsman { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Score != 0 { + data[i] = 0x4d + i++ + i = encodeFixed32Theproto3(data, i, uint32(math.Float32bits(m.Score))) + } + if len(m.Terrain) > 0 { + keysForTerrain := make([]int64, 0, len(m.Terrain)) + for k := range m.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + for _, k := range keysForTerrain { + data[i] = 0x52 + i++ + v := m.Terrain[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + msgSize + sovTheproto3(uint64(msgSize)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(v.Size())) + n2, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + } + } + if m.Proto2Field != nil { + data[i] = 0x5a + i++ + i = encodeVarintTheproto3(data, i, uint64(m.Proto2Field.Size())) + n3, err := m.Proto2Field.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n3 + } + if len(m.Proto2Value) > 0 { + keysForProto2Value := make([]int64, 0, len(m.Proto2Value)) + for k := range m.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + for _, k := range keysForProto2Value { + data[i] = 0x6a + i++ + v := m.Proto2Value[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + msgSize + sovTheproto3(uint64(msgSize)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(v.Size())) + n4, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n4 + } + } + return i, nil +} + +func (m *Nested) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Nested) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Bunny) > 0 { + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(m.Bunny))) + i += copy(data[i:], m.Bunny) + } + return i, nil +} + +func (m *AllMaps) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AllMaps) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + keysForStringToDoubleMap := make([]string, 0, len(m.StringToDoubleMap)) + for k := range m.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + for _, k := range keysForStringToDoubleMap { + data[i] = 0xa + i++ + v := m.StringToDoubleMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x11 + i++ + i = encodeFixed64Theproto3(data, i, uint64(math.Float64bits(v))) + } + } + if len(m.StringToFloatMap) > 0 { + keysForStringToFloatMap := make([]string, 0, len(m.StringToFloatMap)) + for k := range m.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + for _, k := range keysForStringToFloatMap { + data[i] = 0x12 + i++ + v := m.StringToFloatMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x15 + i++ + i = encodeFixed32Theproto3(data, i, uint32(math.Float32bits(v))) + } + } + if len(m.Int32Map) > 0 { + keysForInt32Map := make([]int32, 0, len(m.Int32Map)) + for k := range m.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + for _, k := range keysForInt32Map { + data[i] = 0x1a + i++ + v := m.Int32Map[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.Int64Map) > 0 { + keysForInt64Map := make([]int64, 0, len(m.Int64Map)) + for k := range m.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + for _, k := range keysForInt64Map { + data[i] = 0x22 + i++ + v := m.Int64Map[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.Uint32Map) > 0 { + keysForUint32Map := make([]uint32, 0, len(m.Uint32Map)) + for k := range m.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + for _, k := range keysForUint32Map { + data[i] = 0x2a + i++ + v := m.Uint32Map[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.Uint64Map) > 0 { + keysForUint64Map := make([]uint64, 0, len(m.Uint64Map)) + for k := range m.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + for _, k := range keysForUint64Map { + data[i] = 0x32 + i++ + v := m.Uint64Map[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.Sint32Map) > 0 { + keysForSint32Map := make([]int32, 0, len(m.Sint32Map)) + for k := range m.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + for _, k := range keysForSint32Map { + data[i] = 0x3a + i++ + v := m.Sint32Map[k] + mapSize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint32(k)<<1)^uint32((k>>31)))) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint32(v)<<1)^uint32((v>>31)))) + } + } + if len(m.Sint64Map) > 0 { + keysForSint64Map := make([]int64, 0, len(m.Sint64Map)) + for k := range m.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + for _, k := range keysForSint64Map { + data[i] = 0x42 + i++ + v := m.Sint64Map[k] + mapSize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint64(k)<<1)^uint64((k>>63)))) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint64(v)<<1)^uint64((v>>63)))) + } + } + if len(m.Fixed32Map) > 0 { + keysForFixed32Map := make([]uint32, 0, len(m.Fixed32Map)) + for k := range m.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + for _, k := range keysForFixed32Map { + data[i] = 0x4a + i++ + v := m.Fixed32Map[k] + mapSize := 1 + 4 + 1 + 4 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xd + i++ + i = encodeFixed32Theproto3(data, i, uint32(k)) + data[i] = 0x15 + i++ + i = encodeFixed32Theproto3(data, i, uint32(v)) + } + } + if len(m.Sfixed32Map) > 0 { + keysForSfixed32Map := make([]int32, 0, len(m.Sfixed32Map)) + for k := range m.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + for _, k := range keysForSfixed32Map { + data[i] = 0x52 + i++ + v := m.Sfixed32Map[k] + mapSize := 1 + 4 + 1 + 4 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xd + i++ + i = encodeFixed32Theproto3(data, i, uint32(k)) + data[i] = 0x15 + i++ + i = encodeFixed32Theproto3(data, i, uint32(v)) + } + } + if len(m.Fixed64Map) > 0 { + keysForFixed64Map := make([]uint64, 0, len(m.Fixed64Map)) + for k := range m.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + for _, k := range keysForFixed64Map { + data[i] = 0x5a + i++ + v := m.Fixed64Map[k] + mapSize := 1 + 8 + 1 + 8 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x9 + i++ + i = encodeFixed64Theproto3(data, i, uint64(k)) + data[i] = 0x11 + i++ + i = encodeFixed64Theproto3(data, i, uint64(v)) + } + } + if len(m.Sfixed64Map) > 0 { + keysForSfixed64Map := make([]int64, 0, len(m.Sfixed64Map)) + for k := range m.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + for _, k := range keysForSfixed64Map { + data[i] = 0x62 + i++ + v := m.Sfixed64Map[k] + mapSize := 1 + 8 + 1 + 8 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x9 + i++ + i = encodeFixed64Theproto3(data, i, uint64(k)) + data[i] = 0x11 + i++ + i = encodeFixed64Theproto3(data, i, uint64(v)) + } + } + if len(m.BoolMap) > 0 { + keysForBoolMap := make([]bool, 0, len(m.BoolMap)) + for k := range m.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + for _, k := range keysForBoolMap { + data[i] = 0x6a + i++ + v := m.BoolMap[k] + mapSize := 1 + 1 + 1 + 1 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + if k { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x10 + i++ + if v { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.StringMap) > 0 { + keysForStringMap := make([]string, 0, len(m.StringMap)) + for k := range m.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + for _, k := range keysForStringMap { + data[i] = 0x72 + i++ + v := m.StringMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.StringToBytesMap) > 0 { + keysForStringToBytesMap := make([]string, 0, len(m.StringToBytesMap)) + for k := range m.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + for _, k := range keysForStringToBytesMap { + data[i] = 0x7a + i++ + v := m.StringToBytesMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.StringToEnumMap) > 0 { + keysForStringToEnumMap := make([]string, 0, len(m.StringToEnumMap)) + for k := range m.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + for _, k := range keysForStringToEnumMap { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + v := m.StringToEnumMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.StringToMsgMap) > 0 { + keysForStringToMsgMap := make([]string, 0, len(m.StringToMsgMap)) + for k := range m.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + for _, k := range keysForStringToMsgMap { + data[i] = 0x8a + i++ + data[i] = 0x1 + i++ + v := m.StringToMsgMap[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + msgSize + sovTheproto3(uint64(msgSize)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(v.Size())) + n5, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n5 + } + } + return i, nil +} + +func (m *MessageWithMap) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *MessageWithMap) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.NameMapping) > 0 { + keysForNameMapping := make([]int32, 0, len(m.NameMapping)) + for k := range m.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + for _, k := range keysForNameMapping { + data[i] = 0xa + i++ + v := m.NameMapping[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + len(v) + sovTheproto3(uint64(len(v))) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.MsgMapping) > 0 { + keysForMsgMapping := make([]int64, 0, len(m.MsgMapping)) + for k := range m.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + for _, k := range keysForMsgMapping { + data[i] = 0x12 + i++ + v := m.MsgMapping[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + sozTheproto3(uint64(k)) + 1 + msgSize + sovTheproto3(uint64(msgSize)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint64(k)<<1)^uint64((k>>63)))) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(v.Size())) + n6, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n6 + } + } + if len(m.ByteMapping) > 0 { + keysForByteMapping := make([]bool, 0, len(m.ByteMapping)) + for k := range m.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + for _, k := range keysForByteMapping { + data[i] = 0x1a + i++ + v := m.ByteMapping[k] + mapSize := 1 + 1 + 1 + len(v) + sovTheproto3(uint64(len(v))) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + if k { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + return i, nil +} + +func (m *FloatingPoint) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *FloatingPoint) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.F != 0 { + data[i] = 0x9 + i++ + i = encodeFixed64Theproto3(data, i, uint64(math.Float64bits(m.F))) + } + return i, nil +} + +func encodeFixed64Theproto3(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Theproto3(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintTheproto3(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedMessage(r randyTheproto3, easy bool) *Message { + this := &Message{} + this.Name = randStringTheproto3(r) + this.Hilarity = Message_Humour([]int32{0, 1, 2, 3}[r.Intn(4)]) + this.HeightInCm = uint32(r.Uint32()) + v1 := r.Intn(100) + this.Data = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Data[i] = byte(r.Intn(256)) + } + v2 := r.Intn(100) + this.Key = make([]uint64, v2) + for i := 0; i < v2; i++ { + this.Key[i] = uint64(uint64(r.Uint32())) + } + if r.Intn(10) != 0 { + this.Nested = NewPopulatedNested(r, easy) + } + this.ResultCount = int64(r.Int63()) + if r.Intn(2) == 0 { + this.ResultCount *= -1 + } + this.TrueScotsman = bool(bool(r.Intn(2) == 0)) + this.Score = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Score *= -1 + } + if r.Intn(10) != 0 { + v3 := r.Intn(10) + this.Terrain = make(map[int64]*Nested) + for i := 0; i < v3; i++ { + this.Terrain[int64(r.Int63())] = NewPopulatedNested(r, easy) + } + } + if r.Intn(10) != 0 { + this.Proto2Field = test.NewPopulatedNinOptNative(r, easy) + } + if r.Intn(10) != 0 { + v4 := r.Intn(10) + this.Proto2Value = make(map[int64]*test.NinOptEnum) + for i := 0; i < v4; i++ { + this.Proto2Value[int64(r.Int63())] = test.NewPopulatedNinOptEnum(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedNested(r randyTheproto3, easy bool) *Nested { + this := &Nested{} + this.Bunny = randStringTheproto3(r) + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedAllMaps(r randyTheproto3, easy bool) *AllMaps { + this := &AllMaps{} + if r.Intn(10) != 0 { + v5 := r.Intn(10) + this.StringToDoubleMap = make(map[string]float64) + for i := 0; i < v5; i++ { + v6 := randStringTheproto3(r) + this.StringToDoubleMap[v6] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.StringToDoubleMap[v6] *= -1 + } + } + } + if r.Intn(10) != 0 { + v7 := r.Intn(10) + this.StringToFloatMap = make(map[string]float32) + for i := 0; i < v7; i++ { + v8 := randStringTheproto3(r) + this.StringToFloatMap[v8] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.StringToFloatMap[v8] *= -1 + } + } + } + if r.Intn(10) != 0 { + v9 := r.Intn(10) + this.Int32Map = make(map[int32]int32) + for i := 0; i < v9; i++ { + v10 := int32(r.Int31()) + this.Int32Map[v10] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Int32Map[v10] *= -1 + } + } + } + if r.Intn(10) != 0 { + v11 := r.Intn(10) + this.Int64Map = make(map[int64]int64) + for i := 0; i < v11; i++ { + v12 := int64(r.Int63()) + this.Int64Map[v12] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Int64Map[v12] *= -1 + } + } + } + if r.Intn(10) != 0 { + v13 := r.Intn(10) + this.Uint32Map = make(map[uint32]uint32) + for i := 0; i < v13; i++ { + v14 := uint32(r.Uint32()) + this.Uint32Map[v14] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v15 := r.Intn(10) + this.Uint64Map = make(map[uint64]uint64) + for i := 0; i < v15; i++ { + v16 := uint64(uint64(r.Uint32())) + this.Uint64Map[v16] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v17 := r.Intn(10) + this.Sint32Map = make(map[int32]int32) + for i := 0; i < v17; i++ { + v18 := int32(r.Int31()) + this.Sint32Map[v18] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sint32Map[v18] *= -1 + } + } + } + if r.Intn(10) != 0 { + v19 := r.Intn(10) + this.Sint64Map = make(map[int64]int64) + for i := 0; i < v19; i++ { + v20 := int64(r.Int63()) + this.Sint64Map[v20] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sint64Map[v20] *= -1 + } + } + } + if r.Intn(10) != 0 { + v21 := r.Intn(10) + this.Fixed32Map = make(map[uint32]uint32) + for i := 0; i < v21; i++ { + v22 := uint32(r.Uint32()) + this.Fixed32Map[v22] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v23 := r.Intn(10) + this.Sfixed32Map = make(map[int32]int32) + for i := 0; i < v23; i++ { + v24 := int32(r.Int31()) + this.Sfixed32Map[v24] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sfixed32Map[v24] *= -1 + } + } + } + if r.Intn(10) != 0 { + v25 := r.Intn(10) + this.Fixed64Map = make(map[uint64]uint64) + for i := 0; i < v25; i++ { + v26 := uint64(uint64(r.Uint32())) + this.Fixed64Map[v26] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v27 := r.Intn(10) + this.Sfixed64Map = make(map[int64]int64) + for i := 0; i < v27; i++ { + v28 := int64(r.Int63()) + this.Sfixed64Map[v28] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sfixed64Map[v28] *= -1 + } + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(10) + this.BoolMap = make(map[bool]bool) + for i := 0; i < v29; i++ { + v30 := bool(bool(r.Intn(2) == 0)) + this.BoolMap[v30] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v31 := r.Intn(10) + this.StringMap = make(map[string]string) + for i := 0; i < v31; i++ { + this.StringMap[randStringTheproto3(r)] = randStringTheproto3(r) + } + } + if r.Intn(10) != 0 { + v32 := r.Intn(10) + this.StringToBytesMap = make(map[string][]byte) + for i := 0; i < v32; i++ { + v33 := r.Intn(100) + v34 := randStringTheproto3(r) + this.StringToBytesMap[v34] = make([]byte, v33) + for i := 0; i < v33; i++ { + this.StringToBytesMap[v34][i] = byte(r.Intn(256)) + } + } + } + if r.Intn(10) != 0 { + v35 := r.Intn(10) + this.StringToEnumMap = make(map[string]MapEnum) + for i := 0; i < v35; i++ { + this.StringToEnumMap[randStringTheproto3(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if r.Intn(10) != 0 { + v36 := r.Intn(10) + this.StringToMsgMap = make(map[string]*FloatingPoint) + for i := 0; i < v36; i++ { + this.StringToMsgMap[randStringTheproto3(r)] = NewPopulatedFloatingPoint(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedMessageWithMap(r randyTheproto3, easy bool) *MessageWithMap { + this := &MessageWithMap{} + if r.Intn(10) != 0 { + v37 := r.Intn(10) + this.NameMapping = make(map[int32]string) + for i := 0; i < v37; i++ { + this.NameMapping[int32(r.Int31())] = randStringTheproto3(r) + } + } + if r.Intn(10) != 0 { + v38 := r.Intn(10) + this.MsgMapping = make(map[int64]*FloatingPoint) + for i := 0; i < v38; i++ { + this.MsgMapping[int64(r.Int63())] = NewPopulatedFloatingPoint(r, easy) + } + } + if r.Intn(10) != 0 { + v39 := r.Intn(10) + this.ByteMapping = make(map[bool][]byte) + for i := 0; i < v39; i++ { + v40 := r.Intn(100) + v41 := bool(bool(r.Intn(2) == 0)) + this.ByteMapping[v41] = make([]byte, v40) + for i := 0; i < v40; i++ { + this.ByteMapping[v41][i] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedFloatingPoint(r randyTheproto3, easy bool) *FloatingPoint { + this := &FloatingPoint{} + this.F = float64(r.Float64()) + if r.Intn(2) == 0 { + this.F *= -1 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +type randyTheproto3 interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneTheproto3(r randyTheproto3) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringTheproto3(r randyTheproto3) string { + v42 := r.Intn(100) + tmps := make([]rune, v42) + for i := 0; i < v42; i++ { + tmps[i] = randUTF8RuneTheproto3(r) + } + return string(tmps) +} +func randUnrecognizedTheproto3(r randyTheproto3, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldTheproto3(data, r, fieldNumber, wire) + } + return data +} +func randFieldTheproto3(data []byte, r randyTheproto3, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + v43 := r.Int63() + if r.Intn(2) == 0 { + v43 *= -1 + } + data = encodeVarintPopulateTheproto3(data, uint64(v43)) + case 1: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateTheproto3(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateTheproto3(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Message) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + if m.Hilarity != 0 { + n += 1 + sovTheproto3(uint64(m.Hilarity)) + } + if m.HeightInCm != 0 { + n += 1 + sovTheproto3(uint64(m.HeightInCm)) + } + if m.Data != nil { + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + } + if len(m.Key) > 0 { + for _, e := range m.Key { + n += 1 + sovTheproto3(uint64(e)) + } + } + if m.Nested != nil { + l = m.Nested.Size() + n += 1 + l + sovTheproto3(uint64(l)) + } + if m.ResultCount != 0 { + n += 1 + sovTheproto3(uint64(m.ResultCount)) + } + if m.TrueScotsman { + n += 2 + } + if m.Score != 0 { + n += 5 + } + if len(m.Terrain) > 0 { + for k, v := range m.Terrain { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if m.Proto2Field != nil { + l = m.Proto2Field.Size() + n += 1 + l + sovTheproto3(uint64(l)) + } + if len(m.Proto2Value) > 0 { + for k, v := range m.Proto2Value { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *Nested) Size() (n int) { + var l int + _ = l + l = len(m.Bunny) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + return n +} + +func (m *AllMaps) Size() (n int) { + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + for k, v := range m.StringToDoubleMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToFloatMap) > 0 { + for k, v := range m.StringToFloatMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Int32Map) > 0 { + for k, v := range m.Int32Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Int64Map) > 0 { + for k, v := range m.Int64Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Uint32Map) > 0 { + for k, v := range m.Uint32Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Uint64Map) > 0 { + for k, v := range m.Uint64Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sint32Map) > 0 { + for k, v := range m.Sint32Map { + _ = k + _ = v + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sint64Map) > 0 { + for k, v := range m.Sint64Map { + _ = k + _ = v + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Fixed32Map) > 0 { + for k, v := range m.Fixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sfixed32Map) > 0 { + for k, v := range m.Sfixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Fixed64Map) > 0 { + for k, v := range m.Fixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sfixed64Map) > 0 { + for k, v := range m.Sfixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.BoolMap) > 0 { + for k, v := range m.BoolMap { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + 1 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringMap) > 0 { + for k, v := range m.StringMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToBytesMap) > 0 { + for k, v := range m.StringToBytesMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToEnumMap) > 0 { + for k, v := range m.StringToEnumMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToMsgMap) > 0 { + for k, v := range m.StringToMsgMap { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *MessageWithMap) Size() (n int) { + var l int + _ = l + if len(m.NameMapping) > 0 { + for k, v := range m.NameMapping { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.MsgMapping) > 0 { + for k, v := range m.MsgMapping { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.ByteMapping) > 0 { + for k, v := range m.ByteMapping { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *FloatingPoint) Size() (n int) { + var l int + _ = l + if m.F != 0 { + n += 9 + } + return n +} + +func sovTheproto3(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozTheproto3(x uint64) (n int) { + return sovTheproto3(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Message) String() string { + if this == nil { + return "nil" + } + keysForTerrain := make([]int64, 0, len(this.Terrain)) + for k := range this.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + mapStringForTerrain := "map[int64]*Nested{" + for _, k := range keysForTerrain { + mapStringForTerrain += fmt.Sprintf("%v: %v,", k, this.Terrain[k]) + } + mapStringForTerrain += "}" + keysForProto2Value := make([]int64, 0, len(this.Proto2Value)) + for k := range this.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + mapStringForProto2Value := "map[int64]*test.NinOptEnum{" + for _, k := range keysForProto2Value { + mapStringForProto2Value += fmt.Sprintf("%v: %v,", k, this.Proto2Value[k]) + } + mapStringForProto2Value += "}" + s := strings.Join([]string{`&Message{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Hilarity:` + fmt.Sprintf("%v", this.Hilarity) + `,`, + `HeightInCm:` + fmt.Sprintf("%v", this.HeightInCm) + `,`, + `Data:` + fmt.Sprintf("%v", this.Data) + `,`, + `Key:` + fmt.Sprintf("%v", this.Key) + `,`, + `Nested:` + strings.Replace(fmt.Sprintf("%v", this.Nested), "Nested", "Nested", 1) + `,`, + `ResultCount:` + fmt.Sprintf("%v", this.ResultCount) + `,`, + `TrueScotsman:` + fmt.Sprintf("%v", this.TrueScotsman) + `,`, + `Score:` + fmt.Sprintf("%v", this.Score) + `,`, + `Terrain:` + mapStringForTerrain + `,`, + `Proto2Field:` + strings.Replace(fmt.Sprintf("%v", this.Proto2Field), "NinOptNative", "test.NinOptNative", 1) + `,`, + `Proto2Value:` + mapStringForProto2Value + `,`, + `}`, + }, "") + return s +} +func (this *Nested) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Nested{`, + `Bunny:` + fmt.Sprintf("%v", this.Bunny) + `,`, + `}`, + }, "") + return s +} +func (this *AllMaps) String() string { + if this == nil { + return "nil" + } + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + s := strings.Join([]string{`&AllMaps{`, + `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`, + `StringToFloatMap:` + mapStringForStringToFloatMap + `,`, + `Int32Map:` + mapStringForInt32Map + `,`, + `Int64Map:` + mapStringForInt64Map + `,`, + `Uint32Map:` + mapStringForUint32Map + `,`, + `Uint64Map:` + mapStringForUint64Map + `,`, + `Sint32Map:` + mapStringForSint32Map + `,`, + `Sint64Map:` + mapStringForSint64Map + `,`, + `Fixed32Map:` + mapStringForFixed32Map + `,`, + `Sfixed32Map:` + mapStringForSfixed32Map + `,`, + `Fixed64Map:` + mapStringForFixed64Map + `,`, + `Sfixed64Map:` + mapStringForSfixed64Map + `,`, + `BoolMap:` + mapStringForBoolMap + `,`, + `StringMap:` + mapStringForStringMap + `,`, + `StringToBytesMap:` + mapStringForStringToBytesMap + `,`, + `StringToEnumMap:` + mapStringForStringToEnumMap + `,`, + `StringToMsgMap:` + mapStringForStringToMsgMap + `,`, + `}`, + }, "") + return s +} +func (this *MessageWithMap) String() string { + if this == nil { + return "nil" + } + keysForNameMapping := make([]int32, 0, len(this.NameMapping)) + for k := range this.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + mapStringForNameMapping := "map[int32]string{" + for _, k := range keysForNameMapping { + mapStringForNameMapping += fmt.Sprintf("%v: %v,", k, this.NameMapping[k]) + } + mapStringForNameMapping += "}" + keysForMsgMapping := make([]int64, 0, len(this.MsgMapping)) + for k := range this.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + mapStringForMsgMapping := "map[int64]*FloatingPoint{" + for _, k := range keysForMsgMapping { + mapStringForMsgMapping += fmt.Sprintf("%v: %v,", k, this.MsgMapping[k]) + } + mapStringForMsgMapping += "}" + keysForByteMapping := make([]bool, 0, len(this.ByteMapping)) + for k := range this.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + mapStringForByteMapping := "map[bool][]byte{" + for _, k := range keysForByteMapping { + mapStringForByteMapping += fmt.Sprintf("%v: %v,", k, this.ByteMapping[k]) + } + mapStringForByteMapping += "}" + s := strings.Join([]string{`&MessageWithMap{`, + `NameMapping:` + mapStringForNameMapping + `,`, + `MsgMapping:` + mapStringForMsgMapping + `,`, + `ByteMapping:` + mapStringForByteMapping + `,`, + `}`, + }, "") + return s +} +func (this *FloatingPoint) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FloatingPoint{`, + `F:` + fmt.Sprintf("%v", this.F) + `,`, + `}`, + }, "") + return s +} +func valueToStringTheproto3(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/marshaler/theproto3.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/marshaler/theproto3.proto new file mode 100644 index 0000000000000000000000000000000000000000..37cd6281e637454a3831bf0bcefc4c3d610def6d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/marshaler/theproto3.proto @@ -0,0 +1,129 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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 theproto3; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +import "github.com/gogo/protobuf/test/combos/both/thetest.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Message { + enum Humour { + UNKNOWN = 0; + PUNS = 1; + SLAPSTICK = 2; + BILL_BAILEY = 3; + } + + string name = 1; + Humour hilarity = 2; + uint32 height_in_cm = 3; + bytes data = 4; + int64 result_count = 7; + bool true_scotsman = 8; + float score = 9; + + repeated uint64 key = 5; + Nested nested = 6; + + map terrain = 10; + test.NinOptNative proto2_field = 11; + map proto2_value = 13; +} + +message Nested { + string bunny = 1; +} + +enum MapEnum { + MA = 0; + MB = 1; + MC = 2; +} + +message AllMaps { + map StringToDoubleMap = 1; + map StringToFloatMap = 2; + map Int32Map = 3; + map Int64Map = 4; + map Uint32Map = 5; + map Uint64Map = 6; + map Sint32Map = 7; + map Sint64Map = 8; + map Fixed32Map = 9; + map Sfixed32Map = 10; + map Fixed64Map = 11; + map Sfixed64Map = 12; + map BoolMap = 13; + map StringMap = 14; + map StringToBytesMap = 15; + map StringToEnumMap = 16; + map StringToMsgMap = 17; +} + +message MessageWithMap { + map name_mapping = 1; + map msg_mapping = 2; + map byte_mapping = 3; +} + +message FloatingPoint { + double f = 1; +} \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/marshaler/theproto3pb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/marshaler/theproto3pb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..5ca8e0f09333bf017dc503767025bbc15709889b --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/marshaler/theproto3pb_test.go @@ -0,0 +1,1232 @@ +// Code generated by protoc-gen-gogo. +// source: combos/marshaler/theproto3.proto +// DO NOT EDIT! + +/* +Package theproto3 is a generated protocol buffer package. + +It is generated from these files: + combos/marshaler/theproto3.proto + +It has these top-level messages: + Message + Nested + AllMaps + MessageWithMap + FloatingPoint +*/ +package theproto3 + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" +// discarding unused import test "github.com/gogo/protobuf/test/combos/both" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestMessageProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestMessageMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkMessageProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Message, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMessageProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessage(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Message{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nested, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNested(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNested(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Nested{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAllMapsMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAllMapsProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMaps(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AllMaps{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageWithMapProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestMessageWithMapMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkMessageWithMapProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MessageWithMap, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMessageWithMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMessageWithMapProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessageWithMap(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &MessageWithMap{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestFloatingPointMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkFloatingPointProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedFloatingPoint(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &FloatingPoint{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllMapsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMessageWithMapJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestFloatingPointJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMessageProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Message{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Message{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageWithMapProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageWithMapProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTheproto3Description(t *testing.T) { + Theproto3Description() +} +func TestMessageVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllMapsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMessageWithMapVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestFloatingPointVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMessageFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAllMapsFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestMessageWithMapFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestFloatingPointFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestMessageGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllMapsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMessageWithMapGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestFloatingPointGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMessageSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMessageSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Message, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nested, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNested(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAllMapsSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageWithMapSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMessageWithMapSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MessageWithMap, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMessageWithMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkFloatingPointSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllMapsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestMessageWithMapStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestFloatingPointStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/neither/nilmaps_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/neither/nilmaps_test.go new file mode 100644 index 0000000000000000000000000000000000000000..1b05c72b2c453fe78cac35296c395d0dc5951bc8 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/neither/nilmaps_test.go @@ -0,0 +1,39 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 theproto3 + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "testing" +) + +func TestNilMaps(t *testing.T) { + m := &AllMaps{StringToMsgMap: map[string]*FloatingPoint{"a": nil}} + if _, err := proto.Marshal(m); err == nil { + t.Fatalf("expected error") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/neither/theproto3.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/neither/theproto3.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..f1883d9aaf2e1d8b45febc53af88d3de4928af01 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/neither/theproto3.pb.go @@ -0,0 +1,7589 @@ +// Code generated by protoc-gen-gogo. +// source: combos/neither/theproto3.proto +// DO NOT EDIT! + +/* + Package theproto3 is a generated protocol buffer package. + + It is generated from these files: + combos/neither/theproto3.proto + + It has these top-level messages: + Message + Nested + AllMaps + MessageWithMap + FloatingPoint +*/ +package theproto3 + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" +import test "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" +import github_com_gogo_protobuf_sortkeys "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/sortkeys" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type MapEnum int32 + +const ( + MA MapEnum = 0 + MB MapEnum = 1 + MC MapEnum = 2 +) + +var MapEnum_name = map[int32]string{ + 0: "MA", + 1: "MB", + 2: "MC", +} +var MapEnum_value = map[string]int32{ + "MA": 0, + "MB": 1, + "MC": 2, +} + +type Message_Humour int32 + +const ( + UNKNOWN Message_Humour = 0 + PUNS Message_Humour = 1 + SLAPSTICK Message_Humour = 2 + BILL_BAILEY Message_Humour = 3 +) + +var Message_Humour_name = map[int32]string{ + 0: "UNKNOWN", + 1: "PUNS", + 2: "SLAPSTICK", + 3: "BILL_BAILEY", +} +var Message_Humour_value = map[string]int32{ + "UNKNOWN": 0, + "PUNS": 1, + "SLAPSTICK": 2, + "BILL_BAILEY": 3, +} + +type Message struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Hilarity Message_Humour `protobuf:"varint,2,opt,name=hilarity,proto3,enum=theproto3.Message_Humour" json:"hilarity,omitempty"` + HeightInCm uint32 `protobuf:"varint,3,opt,name=height_in_cm,proto3" json:"height_in_cm,omitempty"` + Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` + ResultCount int64 `protobuf:"varint,7,opt,name=result_count,proto3" json:"result_count,omitempty"` + TrueScotsman bool `protobuf:"varint,8,opt,name=true_scotsman,proto3" json:"true_scotsman,omitempty"` + Score float32 `protobuf:"fixed32,9,opt,name=score,proto3" json:"score,omitempty"` + Key []uint64 `protobuf:"varint,5,rep,name=key" json:"key,omitempty"` + Nested *Nested `protobuf:"bytes,6,opt,name=nested" json:"nested,omitempty"` + Terrain map[int64]*Nested `protobuf:"bytes,10,rep,name=terrain" json:"terrain,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` + Proto2Field *test.NinOptNative `protobuf:"bytes,11,opt,name=proto2_field" json:"proto2_field,omitempty"` + Proto2Value map[int64]*test.NinOptEnum `protobuf:"bytes,13,rep,name=proto2_value" json:"proto2_value,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` +} + +func (m *Message) Reset() { *m = Message{} } +func (*Message) ProtoMessage() {} + +type Nested struct { + Bunny string `protobuf:"bytes,1,opt,name=bunny,proto3" json:"bunny,omitempty"` +} + +func (m *Nested) Reset() { *m = Nested{} } +func (*Nested) ProtoMessage() {} + +type AllMaps struct { + StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key,proto3" protobuf_val:"zigzag32,2,opt,name=value,proto3"` + Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"` + Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=theproto3.MapEnum"` + StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` +} + +func (m *AllMaps) Reset() { *m = AllMaps{} } +func (*AllMaps) ProtoMessage() {} + +type MessageWithMap struct { + NameMapping map[int32]string `protobuf:"bytes,1,rep,name=name_mapping" json:"name_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + MsgMapping map[int64]*FloatingPoint `protobuf:"bytes,2,rep,name=msg_mapping" json:"msg_mapping,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` + ByteMapping map[bool][]byte `protobuf:"bytes,3,rep,name=byte_mapping" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (m *MessageWithMap) Reset() { *m = MessageWithMap{} } +func (*MessageWithMap) ProtoMessage() {} + +type FloatingPoint struct { + F float64 `protobuf:"fixed64,1,opt,name=f,proto3" json:"f,omitempty"` +} + +func (m *FloatingPoint) Reset() { *m = FloatingPoint{} } +func (*FloatingPoint) ProtoMessage() {} + +func init() { + proto.RegisterEnum("theproto3.MapEnum", MapEnum_name, MapEnum_value) + proto.RegisterEnum("theproto3.Message_Humour", Message_Humour_name, Message_Humour_value) +} +func (this *Message) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *Nested) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *AllMaps) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *MessageWithMap) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *FloatingPoint) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func Theproto3Description() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/test/combos/both/thetest.proto"), + Package: func(v string) *string { return &v }("test"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NinRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NidOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }, {Name: func(v string) *string { return &v }("NidNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidRepStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStruct"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinRepStruct"), + }}, + }, {Name: func(v string) *string { return &v }("NidOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomDash"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x64, 0x61, 0x73, 0x68, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NidRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinOptStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinNestedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNativeUnion"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStructUnion"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStructUnion"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Tree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Or"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.OrBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Leaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("OrBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Leaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("StrValue"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepTree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.ADeepBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndDeepBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepLeaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("ADeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndDeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepLeaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Tree"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Nil")}, {Name: func(v string) *string { return &v }("NidOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NidRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + DefaultValue: func(v string) *string { return &v }("C"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + DefaultValue: func(v string) *string { return &v }("E"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Timer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Time1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Time2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Data"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("MyExtendable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("OtherExtenable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("M"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(14), + End: func(v int32) *int32 { return &v }(17), + }, {Start: func(v int32) *int32 { return &v }(10), + End: func(v int32) *int32 { return &v }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("NestedDefinition"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("EnumField"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("NM"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedMessage"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedField1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedMsg"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedField1"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("NestedEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_NESTED"), + Number: func(v int32) *int32 { return &v }(1), + }}, + }}, + }, {Name: func(v string) *string { return &v }("NestedScope"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("true"), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("CustomContainer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("CustomStruct"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptCustom"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x5, 0x46, 0x69, 0x65, 0x6c, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameCustomType"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Ids"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Values"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("CustomNameEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + }, {Name: func(v string) *string { return &v }("NoExtensionsMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0}), 64025: proto.NewExtension([]byte{0xc8, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Unrecognized"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithInner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithInner.Inner"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Inner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithEmbed"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithEmbed.Embedded"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Embedded"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("TheTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }, {Name: func(v string) *string { return &v }("AnotherTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("D"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("E"), + Number: func(v int32) *int32 { return &v }(11), + }}, + Options: &google_protobuf.EnumOptions{XXX_extensions: map[int32]proto.Extension{62001: proto.NewExtension([]byte{0x88, 0xa3, 0x1e, 0x0})}}, + }}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("FieldA"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldB"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldC"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldA1"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldB1"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldC1"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }, {Name: func(v string) *string { return &v }("combos/neither/theproto3.proto"), + Package: func(v string) *string { return &v }("theproto3"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto", "github.com/gogo/protobuf/test/combos/both/thetest.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Message"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("hilarity"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".theproto3.Message.Humour"), + }, {Name: func(v string) *string { return &v }("height_in_cm"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("data"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("result_count"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("true_scotsman"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("score"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("nested"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Nested"), + }, {Name: func(v string) *string { return &v }("terrain"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Message.TerrainEntry"), + }, {Name: func(v string) *string { return &v }("proto2_field"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("proto2_value"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Message.Proto2ValueEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("TerrainEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Nested"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Proto2ValueEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Humour"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("UNKNOWN"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("PUNS"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("SLAPSTICK"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("BILL_BAILEY"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("Nested"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("bunny"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("AllMaps"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMap"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToDoubleMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToFloatMap"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToFloatMapEntry"), + }, {Name: func(v string) *string { return &v }("Int32Map"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Int32MapEntry"), + }, {Name: func(v string) *string { return &v }("Int64Map"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Int64MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint32Map"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Uint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint64Map"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Uint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint32Map"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint64Map"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed32Map"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Fixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed32Map"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sfixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed64Map"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Fixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed64Map"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sfixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("BoolMap"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.BoolMapEntry"), + }, {Name: func(v string) *string { return &v }("StringMap"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToBytesMap"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToBytesMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToEnumMap"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToEnumMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToMsgMap"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToMsgMapEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToFloatMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("BoolMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToBytesMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToEnumMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".theproto3.MapEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToMsgMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("MessageWithMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_mapping"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.NameMappingEntry"), + }, {Name: func(v string) *string { return &v }("msg_mapping"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.MsgMappingEntry"), + }, {Name: func(v string) *string { return &v }("byte_mapping"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.ByteMappingEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NameMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("MsgMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("ByteMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("FloatingPoint"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("f"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("MapEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("MA"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("MB"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("MC"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + Syntax: func(v string) *string { return &v }("proto3"), + }}, + } +} +func (x MapEnum) String() string { + s, ok := MapEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x Message_Humour) String() string { + s, ok := Message_Humour_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *Message) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Message) + if !ok { + return fmt.Errorf("that is not of type *Message") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Message but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Messagebut is not nil && this == nil") + } + if this.Name != that1.Name { + return fmt.Errorf("Name this(%v) Not Equal that(%v)", this.Name, that1.Name) + } + if this.Hilarity != that1.Hilarity { + return fmt.Errorf("Hilarity this(%v) Not Equal that(%v)", this.Hilarity, that1.Hilarity) + } + if this.HeightInCm != that1.HeightInCm { + return fmt.Errorf("HeightInCm this(%v) Not Equal that(%v)", this.HeightInCm, that1.HeightInCm) + } + if !bytes.Equal(this.Data, that1.Data) { + return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data) + } + if this.ResultCount != that1.ResultCount { + return fmt.Errorf("ResultCount this(%v) Not Equal that(%v)", this.ResultCount, that1.ResultCount) + } + if this.TrueScotsman != that1.TrueScotsman { + return fmt.Errorf("TrueScotsman this(%v) Not Equal that(%v)", this.TrueScotsman, that1.TrueScotsman) + } + if this.Score != that1.Score { + return fmt.Errorf("Score this(%v) Not Equal that(%v)", this.Score, that1.Score) + } + if len(this.Key) != len(that1.Key) { + return fmt.Errorf("Key this(%v) Not Equal that(%v)", len(this.Key), len(that1.Key)) + } + for i := range this.Key { + if this.Key[i] != that1.Key[i] { + return fmt.Errorf("Key this[%v](%v) Not Equal that[%v](%v)", i, this.Key[i], i, that1.Key[i]) + } + } + if !this.Nested.Equal(that1.Nested) { + return fmt.Errorf("Nested this(%v) Not Equal that(%v)", this.Nested, that1.Nested) + } + if len(this.Terrain) != len(that1.Terrain) { + return fmt.Errorf("Terrain this(%v) Not Equal that(%v)", len(this.Terrain), len(that1.Terrain)) + } + for i := range this.Terrain { + if !this.Terrain[i].Equal(that1.Terrain[i]) { + return fmt.Errorf("Terrain this[%v](%v) Not Equal that[%v](%v)", i, this.Terrain[i], i, that1.Terrain[i]) + } + } + if !this.Proto2Field.Equal(that1.Proto2Field) { + return fmt.Errorf("Proto2Field this(%v) Not Equal that(%v)", this.Proto2Field, that1.Proto2Field) + } + if len(this.Proto2Value) != len(that1.Proto2Value) { + return fmt.Errorf("Proto2Value this(%v) Not Equal that(%v)", len(this.Proto2Value), len(that1.Proto2Value)) + } + for i := range this.Proto2Value { + if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) { + return fmt.Errorf("Proto2Value this[%v](%v) Not Equal that[%v](%v)", i, this.Proto2Value[i], i, that1.Proto2Value[i]) + } + } + return nil +} +func (this *Message) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Message) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Name != that1.Name { + return false + } + if this.Hilarity != that1.Hilarity { + return false + } + if this.HeightInCm != that1.HeightInCm { + return false + } + if !bytes.Equal(this.Data, that1.Data) { + return false + } + if this.ResultCount != that1.ResultCount { + return false + } + if this.TrueScotsman != that1.TrueScotsman { + return false + } + if this.Score != that1.Score { + return false + } + if len(this.Key) != len(that1.Key) { + return false + } + for i := range this.Key { + if this.Key[i] != that1.Key[i] { + return false + } + } + if !this.Nested.Equal(that1.Nested) { + return false + } + if len(this.Terrain) != len(that1.Terrain) { + return false + } + for i := range this.Terrain { + if !this.Terrain[i].Equal(that1.Terrain[i]) { + return false + } + } + if !this.Proto2Field.Equal(that1.Proto2Field) { + return false + } + if len(this.Proto2Value) != len(that1.Proto2Value) { + return false + } + for i := range this.Proto2Value { + if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) { + return false + } + } + return true +} +func (this *Nested) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Nested) + if !ok { + return fmt.Errorf("that is not of type *Nested") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Nested but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Nestedbut is not nil && this == nil") + } + if this.Bunny != that1.Bunny { + return fmt.Errorf("Bunny this(%v) Not Equal that(%v)", this.Bunny, that1.Bunny) + } + return nil +} +func (this *Nested) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Nested) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Bunny != that1.Bunny { + return false + } + return true +} +func (this *AllMaps) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllMaps) + if !ok { + return fmt.Errorf("that is not of type *AllMaps") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllMaps but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllMapsbut is not nil && this == nil") + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap)) + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i]) + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap)) + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i]) + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map)) + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i]) + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map)) + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i]) + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map)) + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i]) + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map)) + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i]) + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map)) + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i]) + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map)) + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i]) + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map)) + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i]) + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map)) + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i]) + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map)) + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i]) + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map)) + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i]) + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap)) + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i]) + } + } + if len(this.StringMap) != len(that1.StringMap) { + return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap)) + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i]) + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap)) + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i]) + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap)) + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i]) + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap)) + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i]) + } + } + return nil +} +func (this *AllMaps) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllMaps) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return false + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return false + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return false + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return false + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return false + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return false + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return false + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return false + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return false + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return false + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return false + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return false + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return false + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return false + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return false + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return false + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return false + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return false + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return false + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return false + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return false + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return false + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return false + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return false + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return false + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return false + } + } + if len(this.StringMap) != len(that1.StringMap) { + return false + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return false + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return false + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return false + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return false + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return false + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return false + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return false + } + } + return true +} +func (this *MessageWithMap) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*MessageWithMap) + if !ok { + return fmt.Errorf("that is not of type *MessageWithMap") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *MessageWithMap but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *MessageWithMapbut is not nil && this == nil") + } + if len(this.NameMapping) != len(that1.NameMapping) { + return fmt.Errorf("NameMapping this(%v) Not Equal that(%v)", len(this.NameMapping), len(that1.NameMapping)) + } + for i := range this.NameMapping { + if this.NameMapping[i] != that1.NameMapping[i] { + return fmt.Errorf("NameMapping this[%v](%v) Not Equal that[%v](%v)", i, this.NameMapping[i], i, that1.NameMapping[i]) + } + } + if len(this.MsgMapping) != len(that1.MsgMapping) { + return fmt.Errorf("MsgMapping this(%v) Not Equal that(%v)", len(this.MsgMapping), len(that1.MsgMapping)) + } + for i := range this.MsgMapping { + if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) { + return fmt.Errorf("MsgMapping this[%v](%v) Not Equal that[%v](%v)", i, this.MsgMapping[i], i, that1.MsgMapping[i]) + } + } + if len(this.ByteMapping) != len(that1.ByteMapping) { + return fmt.Errorf("ByteMapping this(%v) Not Equal that(%v)", len(this.ByteMapping), len(that1.ByteMapping)) + } + for i := range this.ByteMapping { + if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) { + return fmt.Errorf("ByteMapping this[%v](%v) Not Equal that[%v](%v)", i, this.ByteMapping[i], i, that1.ByteMapping[i]) + } + } + return nil +} +func (this *MessageWithMap) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*MessageWithMap) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.NameMapping) != len(that1.NameMapping) { + return false + } + for i := range this.NameMapping { + if this.NameMapping[i] != that1.NameMapping[i] { + return false + } + } + if len(this.MsgMapping) != len(that1.MsgMapping) { + return false + } + for i := range this.MsgMapping { + if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) { + return false + } + } + if len(this.ByteMapping) != len(that1.ByteMapping) { + return false + } + for i := range this.ByteMapping { + if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) { + return false + } + } + return true +} +func (this *FloatingPoint) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return fmt.Errorf("that is not of type *FloatingPoint") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *FloatingPointbut is not nil && this == nil") + } + if this.F != that1.F { + return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F) + } + return nil +} +func (this *FloatingPoint) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.F != that1.F { + return false + } + return true +} + +type MessageFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetName() string + GetHilarity() Message_Humour + GetHeightInCm() uint32 + GetData() []byte + GetResultCount() int64 + GetTrueScotsman() bool + GetScore() float32 + GetKey() []uint64 + GetNested() *Nested + GetTerrain() map[int64]*Nested + GetProto2Field() *test.NinOptNative + GetProto2Value() map[int64]*test.NinOptEnum +} + +func (this *Message) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Message) TestProto() github_com_gogo_protobuf_proto.Message { + return NewMessageFromFace(this) +} + +func (this *Message) GetName() string { + return this.Name +} + +func (this *Message) GetHilarity() Message_Humour { + return this.Hilarity +} + +func (this *Message) GetHeightInCm() uint32 { + return this.HeightInCm +} + +func (this *Message) GetData() []byte { + return this.Data +} + +func (this *Message) GetResultCount() int64 { + return this.ResultCount +} + +func (this *Message) GetTrueScotsman() bool { + return this.TrueScotsman +} + +func (this *Message) GetScore() float32 { + return this.Score +} + +func (this *Message) GetKey() []uint64 { + return this.Key +} + +func (this *Message) GetNested() *Nested { + return this.Nested +} + +func (this *Message) GetTerrain() map[int64]*Nested { + return this.Terrain +} + +func (this *Message) GetProto2Field() *test.NinOptNative { + return this.Proto2Field +} + +func (this *Message) GetProto2Value() map[int64]*test.NinOptEnum { + return this.Proto2Value +} + +func NewMessageFromFace(that MessageFace) *Message { + this := &Message{} + this.Name = that.GetName() + this.Hilarity = that.GetHilarity() + this.HeightInCm = that.GetHeightInCm() + this.Data = that.GetData() + this.ResultCount = that.GetResultCount() + this.TrueScotsman = that.GetTrueScotsman() + this.Score = that.GetScore() + this.Key = that.GetKey() + this.Nested = that.GetNested() + this.Terrain = that.GetTerrain() + this.Proto2Field = that.GetProto2Field() + this.Proto2Value = that.GetProto2Value() + return this +} + +type NestedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetBunny() string +} + +func (this *Nested) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Nested) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedFromFace(this) +} + +func (this *Nested) GetBunny() string { + return this.Bunny +} + +func NewNestedFromFace(that NestedFace) *Nested { + this := &Nested{} + this.Bunny = that.GetBunny() + return this +} + +type AllMapsFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetStringToDoubleMap() map[string]float64 + GetStringToFloatMap() map[string]float32 + GetInt32Map() map[int32]int32 + GetInt64Map() map[int64]int64 + GetUint32Map() map[uint32]uint32 + GetUint64Map() map[uint64]uint64 + GetSint32Map() map[int32]int32 + GetSint64Map() map[int64]int64 + GetFixed32Map() map[uint32]uint32 + GetSfixed32Map() map[int32]int32 + GetFixed64Map() map[uint64]uint64 + GetSfixed64Map() map[int64]int64 + GetBoolMap() map[bool]bool + GetStringMap() map[string]string + GetStringToBytesMap() map[string][]byte + GetStringToEnumMap() map[string]MapEnum + GetStringToMsgMap() map[string]*FloatingPoint +} + +func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAllMapsFromFace(this) +} + +func (this *AllMaps) GetStringToDoubleMap() map[string]float64 { + return this.StringToDoubleMap +} + +func (this *AllMaps) GetStringToFloatMap() map[string]float32 { + return this.StringToFloatMap +} + +func (this *AllMaps) GetInt32Map() map[int32]int32 { + return this.Int32Map +} + +func (this *AllMaps) GetInt64Map() map[int64]int64 { + return this.Int64Map +} + +func (this *AllMaps) GetUint32Map() map[uint32]uint32 { + return this.Uint32Map +} + +func (this *AllMaps) GetUint64Map() map[uint64]uint64 { + return this.Uint64Map +} + +func (this *AllMaps) GetSint32Map() map[int32]int32 { + return this.Sint32Map +} + +func (this *AllMaps) GetSint64Map() map[int64]int64 { + return this.Sint64Map +} + +func (this *AllMaps) GetFixed32Map() map[uint32]uint32 { + return this.Fixed32Map +} + +func (this *AllMaps) GetSfixed32Map() map[int32]int32 { + return this.Sfixed32Map +} + +func (this *AllMaps) GetFixed64Map() map[uint64]uint64 { + return this.Fixed64Map +} + +func (this *AllMaps) GetSfixed64Map() map[int64]int64 { + return this.Sfixed64Map +} + +func (this *AllMaps) GetBoolMap() map[bool]bool { + return this.BoolMap +} + +func (this *AllMaps) GetStringMap() map[string]string { + return this.StringMap +} + +func (this *AllMaps) GetStringToBytesMap() map[string][]byte { + return this.StringToBytesMap +} + +func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum { + return this.StringToEnumMap +} + +func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint { + return this.StringToMsgMap +} + +func NewAllMapsFromFace(that AllMapsFace) *AllMaps { + this := &AllMaps{} + this.StringToDoubleMap = that.GetStringToDoubleMap() + this.StringToFloatMap = that.GetStringToFloatMap() + this.Int32Map = that.GetInt32Map() + this.Int64Map = that.GetInt64Map() + this.Uint32Map = that.GetUint32Map() + this.Uint64Map = that.GetUint64Map() + this.Sint32Map = that.GetSint32Map() + this.Sint64Map = that.GetSint64Map() + this.Fixed32Map = that.GetFixed32Map() + this.Sfixed32Map = that.GetSfixed32Map() + this.Fixed64Map = that.GetFixed64Map() + this.Sfixed64Map = that.GetSfixed64Map() + this.BoolMap = that.GetBoolMap() + this.StringMap = that.GetStringMap() + this.StringToBytesMap = that.GetStringToBytesMap() + this.StringToEnumMap = that.GetStringToEnumMap() + this.StringToMsgMap = that.GetStringToMsgMap() + return this +} + +type MessageWithMapFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNameMapping() map[int32]string + GetMsgMapping() map[int64]*FloatingPoint + GetByteMapping() map[bool][]byte +} + +func (this *MessageWithMap) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *MessageWithMap) TestProto() github_com_gogo_protobuf_proto.Message { + return NewMessageWithMapFromFace(this) +} + +func (this *MessageWithMap) GetNameMapping() map[int32]string { + return this.NameMapping +} + +func (this *MessageWithMap) GetMsgMapping() map[int64]*FloatingPoint { + return this.MsgMapping +} + +func (this *MessageWithMap) GetByteMapping() map[bool][]byte { + return this.ByteMapping +} + +func NewMessageWithMapFromFace(that MessageWithMapFace) *MessageWithMap { + this := &MessageWithMap{} + this.NameMapping = that.GetNameMapping() + this.MsgMapping = that.GetMsgMapping() + this.ByteMapping = that.GetByteMapping() + return this +} + +type FloatingPointFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetF() float64 +} + +func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message { + return NewFloatingPointFromFace(this) +} + +func (this *FloatingPoint) GetF() float64 { + return this.F +} + +func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint { + this := &FloatingPoint{} + this.F = that.GetF() + return this +} + +func (this *Message) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 16) + s = append(s, "&theproto3.Message{") + s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n") + s = append(s, "Hilarity: "+fmt.Sprintf("%#v", this.Hilarity)+",\n") + s = append(s, "HeightInCm: "+fmt.Sprintf("%#v", this.HeightInCm)+",\n") + s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") + s = append(s, "ResultCount: "+fmt.Sprintf("%#v", this.ResultCount)+",\n") + s = append(s, "TrueScotsman: "+fmt.Sprintf("%#v", this.TrueScotsman)+",\n") + s = append(s, "Score: "+fmt.Sprintf("%#v", this.Score)+",\n") + s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n") + if this.Nested != nil { + s = append(s, "Nested: "+fmt.Sprintf("%#v", this.Nested)+",\n") + } + keysForTerrain := make([]int64, 0, len(this.Terrain)) + for k := range this.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + mapStringForTerrain := "map[int64]*Nested{" + for _, k := range keysForTerrain { + mapStringForTerrain += fmt.Sprintf("%#v: %#v,", k, this.Terrain[k]) + } + mapStringForTerrain += "}" + if this.Terrain != nil { + s = append(s, "Terrain: "+mapStringForTerrain+",\n") + } + if this.Proto2Field != nil { + s = append(s, "Proto2Field: "+fmt.Sprintf("%#v", this.Proto2Field)+",\n") + } + keysForProto2Value := make([]int64, 0, len(this.Proto2Value)) + for k := range this.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + mapStringForProto2Value := "map[int64]*test.NinOptEnum{" + for _, k := range keysForProto2Value { + mapStringForProto2Value += fmt.Sprintf("%#v: %#v,", k, this.Proto2Value[k]) + } + mapStringForProto2Value += "}" + if this.Proto2Value != nil { + s = append(s, "Proto2Value: "+mapStringForProto2Value+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Nested) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&theproto3.Nested{") + s = append(s, "Bunny: "+fmt.Sprintf("%#v", this.Bunny)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllMaps) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 21) + s = append(s, "&theproto3.AllMaps{") + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + if this.StringToDoubleMap != nil { + s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n") + } + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + if this.StringToFloatMap != nil { + s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n") + } + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + if this.Int32Map != nil { + s = append(s, "Int32Map: "+mapStringForInt32Map+",\n") + } + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + if this.Int64Map != nil { + s = append(s, "Int64Map: "+mapStringForInt64Map+",\n") + } + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + if this.Uint32Map != nil { + s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n") + } + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + if this.Uint64Map != nil { + s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n") + } + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + if this.Sint32Map != nil { + s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n") + } + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + if this.Sint64Map != nil { + s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n") + } + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + if this.Fixed32Map != nil { + s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n") + } + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + if this.Sfixed32Map != nil { + s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n") + } + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + if this.Fixed64Map != nil { + s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n") + } + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + if this.Sfixed64Map != nil { + s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n") + } + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + if this.BoolMap != nil { + s = append(s, "BoolMap: "+mapStringForBoolMap+",\n") + } + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + if this.StringMap != nil { + s = append(s, "StringMap: "+mapStringForStringMap+",\n") + } + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + if this.StringToBytesMap != nil { + s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n") + } + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + if this.StringToEnumMap != nil { + s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n") + } + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + if this.StringToMsgMap != nil { + s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MessageWithMap) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&theproto3.MessageWithMap{") + keysForNameMapping := make([]int32, 0, len(this.NameMapping)) + for k := range this.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + mapStringForNameMapping := "map[int32]string{" + for _, k := range keysForNameMapping { + mapStringForNameMapping += fmt.Sprintf("%#v: %#v,", k, this.NameMapping[k]) + } + mapStringForNameMapping += "}" + if this.NameMapping != nil { + s = append(s, "NameMapping: "+mapStringForNameMapping+",\n") + } + keysForMsgMapping := make([]int64, 0, len(this.MsgMapping)) + for k := range this.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + mapStringForMsgMapping := "map[int64]*FloatingPoint{" + for _, k := range keysForMsgMapping { + mapStringForMsgMapping += fmt.Sprintf("%#v: %#v,", k, this.MsgMapping[k]) + } + mapStringForMsgMapping += "}" + if this.MsgMapping != nil { + s = append(s, "MsgMapping: "+mapStringForMsgMapping+",\n") + } + keysForByteMapping := make([]bool, 0, len(this.ByteMapping)) + for k := range this.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + mapStringForByteMapping := "map[bool][]byte{" + for _, k := range keysForByteMapping { + mapStringForByteMapping += fmt.Sprintf("%#v: %#v,", k, this.ByteMapping[k]) + } + mapStringForByteMapping += "}" + if this.ByteMapping != nil { + s = append(s, "ByteMapping: "+mapStringForByteMapping+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FloatingPoint) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&theproto3.FloatingPoint{") + s = append(s, "F: "+fmt.Sprintf("%#v", this.F)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringTheproto3(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringTheproto3(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedMessage(r randyTheproto3, easy bool) *Message { + this := &Message{} + this.Name = randStringTheproto3(r) + this.Hilarity = Message_Humour([]int32{0, 1, 2, 3}[r.Intn(4)]) + this.HeightInCm = uint32(r.Uint32()) + v1 := r.Intn(100) + this.Data = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Data[i] = byte(r.Intn(256)) + } + this.ResultCount = int64(r.Int63()) + if r.Intn(2) == 0 { + this.ResultCount *= -1 + } + this.TrueScotsman = bool(bool(r.Intn(2) == 0)) + this.Score = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Score *= -1 + } + v2 := r.Intn(100) + this.Key = make([]uint64, v2) + for i := 0; i < v2; i++ { + this.Key[i] = uint64(uint64(r.Uint32())) + } + if r.Intn(10) != 0 { + this.Nested = NewPopulatedNested(r, easy) + } + if r.Intn(10) != 0 { + v3 := r.Intn(10) + this.Terrain = make(map[int64]*Nested) + for i := 0; i < v3; i++ { + this.Terrain[int64(r.Int63())] = NewPopulatedNested(r, easy) + } + } + if r.Intn(10) != 0 { + this.Proto2Field = test.NewPopulatedNinOptNative(r, easy) + } + if r.Intn(10) != 0 { + v4 := r.Intn(10) + this.Proto2Value = make(map[int64]*test.NinOptEnum) + for i := 0; i < v4; i++ { + this.Proto2Value[int64(r.Int63())] = test.NewPopulatedNinOptEnum(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedNested(r randyTheproto3, easy bool) *Nested { + this := &Nested{} + this.Bunny = randStringTheproto3(r) + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedAllMaps(r randyTheproto3, easy bool) *AllMaps { + this := &AllMaps{} + if r.Intn(10) != 0 { + v5 := r.Intn(10) + this.StringToDoubleMap = make(map[string]float64) + for i := 0; i < v5; i++ { + v6 := randStringTheproto3(r) + this.StringToDoubleMap[v6] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.StringToDoubleMap[v6] *= -1 + } + } + } + if r.Intn(10) != 0 { + v7 := r.Intn(10) + this.StringToFloatMap = make(map[string]float32) + for i := 0; i < v7; i++ { + v8 := randStringTheproto3(r) + this.StringToFloatMap[v8] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.StringToFloatMap[v8] *= -1 + } + } + } + if r.Intn(10) != 0 { + v9 := r.Intn(10) + this.Int32Map = make(map[int32]int32) + for i := 0; i < v9; i++ { + v10 := int32(r.Int31()) + this.Int32Map[v10] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Int32Map[v10] *= -1 + } + } + } + if r.Intn(10) != 0 { + v11 := r.Intn(10) + this.Int64Map = make(map[int64]int64) + for i := 0; i < v11; i++ { + v12 := int64(r.Int63()) + this.Int64Map[v12] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Int64Map[v12] *= -1 + } + } + } + if r.Intn(10) != 0 { + v13 := r.Intn(10) + this.Uint32Map = make(map[uint32]uint32) + for i := 0; i < v13; i++ { + v14 := uint32(r.Uint32()) + this.Uint32Map[v14] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v15 := r.Intn(10) + this.Uint64Map = make(map[uint64]uint64) + for i := 0; i < v15; i++ { + v16 := uint64(uint64(r.Uint32())) + this.Uint64Map[v16] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v17 := r.Intn(10) + this.Sint32Map = make(map[int32]int32) + for i := 0; i < v17; i++ { + v18 := int32(r.Int31()) + this.Sint32Map[v18] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sint32Map[v18] *= -1 + } + } + } + if r.Intn(10) != 0 { + v19 := r.Intn(10) + this.Sint64Map = make(map[int64]int64) + for i := 0; i < v19; i++ { + v20 := int64(r.Int63()) + this.Sint64Map[v20] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sint64Map[v20] *= -1 + } + } + } + if r.Intn(10) != 0 { + v21 := r.Intn(10) + this.Fixed32Map = make(map[uint32]uint32) + for i := 0; i < v21; i++ { + v22 := uint32(r.Uint32()) + this.Fixed32Map[v22] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v23 := r.Intn(10) + this.Sfixed32Map = make(map[int32]int32) + for i := 0; i < v23; i++ { + v24 := int32(r.Int31()) + this.Sfixed32Map[v24] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sfixed32Map[v24] *= -1 + } + } + } + if r.Intn(10) != 0 { + v25 := r.Intn(10) + this.Fixed64Map = make(map[uint64]uint64) + for i := 0; i < v25; i++ { + v26 := uint64(uint64(r.Uint32())) + this.Fixed64Map[v26] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v27 := r.Intn(10) + this.Sfixed64Map = make(map[int64]int64) + for i := 0; i < v27; i++ { + v28 := int64(r.Int63()) + this.Sfixed64Map[v28] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sfixed64Map[v28] *= -1 + } + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(10) + this.BoolMap = make(map[bool]bool) + for i := 0; i < v29; i++ { + v30 := bool(bool(r.Intn(2) == 0)) + this.BoolMap[v30] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v31 := r.Intn(10) + this.StringMap = make(map[string]string) + for i := 0; i < v31; i++ { + this.StringMap[randStringTheproto3(r)] = randStringTheproto3(r) + } + } + if r.Intn(10) != 0 { + v32 := r.Intn(10) + this.StringToBytesMap = make(map[string][]byte) + for i := 0; i < v32; i++ { + v33 := r.Intn(100) + v34 := randStringTheproto3(r) + this.StringToBytesMap[v34] = make([]byte, v33) + for i := 0; i < v33; i++ { + this.StringToBytesMap[v34][i] = byte(r.Intn(256)) + } + } + } + if r.Intn(10) != 0 { + v35 := r.Intn(10) + this.StringToEnumMap = make(map[string]MapEnum) + for i := 0; i < v35; i++ { + this.StringToEnumMap[randStringTheproto3(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if r.Intn(10) != 0 { + v36 := r.Intn(10) + this.StringToMsgMap = make(map[string]*FloatingPoint) + for i := 0; i < v36; i++ { + this.StringToMsgMap[randStringTheproto3(r)] = NewPopulatedFloatingPoint(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedMessageWithMap(r randyTheproto3, easy bool) *MessageWithMap { + this := &MessageWithMap{} + if r.Intn(10) != 0 { + v37 := r.Intn(10) + this.NameMapping = make(map[int32]string) + for i := 0; i < v37; i++ { + this.NameMapping[int32(r.Int31())] = randStringTheproto3(r) + } + } + if r.Intn(10) != 0 { + v38 := r.Intn(10) + this.MsgMapping = make(map[int64]*FloatingPoint) + for i := 0; i < v38; i++ { + this.MsgMapping[int64(r.Int63())] = NewPopulatedFloatingPoint(r, easy) + } + } + if r.Intn(10) != 0 { + v39 := r.Intn(10) + this.ByteMapping = make(map[bool][]byte) + for i := 0; i < v39; i++ { + v40 := r.Intn(100) + v41 := bool(bool(r.Intn(2) == 0)) + this.ByteMapping[v41] = make([]byte, v40) + for i := 0; i < v40; i++ { + this.ByteMapping[v41][i] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedFloatingPoint(r randyTheproto3, easy bool) *FloatingPoint { + this := &FloatingPoint{} + this.F = float64(r.Float64()) + if r.Intn(2) == 0 { + this.F *= -1 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +type randyTheproto3 interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneTheproto3(r randyTheproto3) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringTheproto3(r randyTheproto3) string { + v42 := r.Intn(100) + tmps := make([]rune, v42) + for i := 0; i < v42; i++ { + tmps[i] = randUTF8RuneTheproto3(r) + } + return string(tmps) +} +func randUnrecognizedTheproto3(r randyTheproto3, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldTheproto3(data, r, fieldNumber, wire) + } + return data +} +func randFieldTheproto3(data []byte, r randyTheproto3, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + v43 := r.Int63() + if r.Intn(2) == 0 { + v43 *= -1 + } + data = encodeVarintPopulateTheproto3(data, uint64(v43)) + case 1: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateTheproto3(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateTheproto3(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Message) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + if m.Hilarity != 0 { + n += 1 + sovTheproto3(uint64(m.Hilarity)) + } + if m.HeightInCm != 0 { + n += 1 + sovTheproto3(uint64(m.HeightInCm)) + } + if m.Data != nil { + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + } + if m.ResultCount != 0 { + n += 1 + sovTheproto3(uint64(m.ResultCount)) + } + if m.TrueScotsman { + n += 2 + } + if m.Score != 0 { + n += 5 + } + if len(m.Key) > 0 { + for _, e := range m.Key { + n += 1 + sovTheproto3(uint64(e)) + } + } + if m.Nested != nil { + l = m.Nested.Size() + n += 1 + l + sovTheproto3(uint64(l)) + } + if len(m.Terrain) > 0 { + for k, v := range m.Terrain { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if m.Proto2Field != nil { + l = m.Proto2Field.Size() + n += 1 + l + sovTheproto3(uint64(l)) + } + if len(m.Proto2Value) > 0 { + for k, v := range m.Proto2Value { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *Nested) Size() (n int) { + var l int + _ = l + l = len(m.Bunny) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + return n +} + +func (m *AllMaps) Size() (n int) { + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + for k, v := range m.StringToDoubleMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToFloatMap) > 0 { + for k, v := range m.StringToFloatMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Int32Map) > 0 { + for k, v := range m.Int32Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Int64Map) > 0 { + for k, v := range m.Int64Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Uint32Map) > 0 { + for k, v := range m.Uint32Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Uint64Map) > 0 { + for k, v := range m.Uint64Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sint32Map) > 0 { + for k, v := range m.Sint32Map { + _ = k + _ = v + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sint64Map) > 0 { + for k, v := range m.Sint64Map { + _ = k + _ = v + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Fixed32Map) > 0 { + for k, v := range m.Fixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sfixed32Map) > 0 { + for k, v := range m.Sfixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Fixed64Map) > 0 { + for k, v := range m.Fixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sfixed64Map) > 0 { + for k, v := range m.Sfixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.BoolMap) > 0 { + for k, v := range m.BoolMap { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + 1 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringMap) > 0 { + for k, v := range m.StringMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToBytesMap) > 0 { + for k, v := range m.StringToBytesMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToEnumMap) > 0 { + for k, v := range m.StringToEnumMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToMsgMap) > 0 { + for k, v := range m.StringToMsgMap { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *MessageWithMap) Size() (n int) { + var l int + _ = l + if len(m.NameMapping) > 0 { + for k, v := range m.NameMapping { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.MsgMapping) > 0 { + for k, v := range m.MsgMapping { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.ByteMapping) > 0 { + for k, v := range m.ByteMapping { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *FloatingPoint) Size() (n int) { + var l int + _ = l + if m.F != 0 { + n += 9 + } + return n +} + +func sovTheproto3(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozTheproto3(x uint64) (n int) { + return sovTheproto3(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Message) String() string { + if this == nil { + return "nil" + } + keysForTerrain := make([]int64, 0, len(this.Terrain)) + for k := range this.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + mapStringForTerrain := "map[int64]*Nested{" + for _, k := range keysForTerrain { + mapStringForTerrain += fmt.Sprintf("%v: %v,", k, this.Terrain[k]) + } + mapStringForTerrain += "}" + keysForProto2Value := make([]int64, 0, len(this.Proto2Value)) + for k := range this.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + mapStringForProto2Value := "map[int64]*test.NinOptEnum{" + for _, k := range keysForProto2Value { + mapStringForProto2Value += fmt.Sprintf("%v: %v,", k, this.Proto2Value[k]) + } + mapStringForProto2Value += "}" + s := strings.Join([]string{`&Message{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Hilarity:` + fmt.Sprintf("%v", this.Hilarity) + `,`, + `HeightInCm:` + fmt.Sprintf("%v", this.HeightInCm) + `,`, + `Data:` + fmt.Sprintf("%v", this.Data) + `,`, + `ResultCount:` + fmt.Sprintf("%v", this.ResultCount) + `,`, + `TrueScotsman:` + fmt.Sprintf("%v", this.TrueScotsman) + `,`, + `Score:` + fmt.Sprintf("%v", this.Score) + `,`, + `Key:` + fmt.Sprintf("%v", this.Key) + `,`, + `Nested:` + strings.Replace(fmt.Sprintf("%v", this.Nested), "Nested", "Nested", 1) + `,`, + `Terrain:` + mapStringForTerrain + `,`, + `Proto2Field:` + strings.Replace(fmt.Sprintf("%v", this.Proto2Field), "NinOptNative", "test.NinOptNative", 1) + `,`, + `Proto2Value:` + mapStringForProto2Value + `,`, + `}`, + }, "") + return s +} +func (this *Nested) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Nested{`, + `Bunny:` + fmt.Sprintf("%v", this.Bunny) + `,`, + `}`, + }, "") + return s +} +func (this *AllMaps) String() string { + if this == nil { + return "nil" + } + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + s := strings.Join([]string{`&AllMaps{`, + `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`, + `StringToFloatMap:` + mapStringForStringToFloatMap + `,`, + `Int32Map:` + mapStringForInt32Map + `,`, + `Int64Map:` + mapStringForInt64Map + `,`, + `Uint32Map:` + mapStringForUint32Map + `,`, + `Uint64Map:` + mapStringForUint64Map + `,`, + `Sint32Map:` + mapStringForSint32Map + `,`, + `Sint64Map:` + mapStringForSint64Map + `,`, + `Fixed32Map:` + mapStringForFixed32Map + `,`, + `Sfixed32Map:` + mapStringForSfixed32Map + `,`, + `Fixed64Map:` + mapStringForFixed64Map + `,`, + `Sfixed64Map:` + mapStringForSfixed64Map + `,`, + `BoolMap:` + mapStringForBoolMap + `,`, + `StringMap:` + mapStringForStringMap + `,`, + `StringToBytesMap:` + mapStringForStringToBytesMap + `,`, + `StringToEnumMap:` + mapStringForStringToEnumMap + `,`, + `StringToMsgMap:` + mapStringForStringToMsgMap + `,`, + `}`, + }, "") + return s +} +func (this *MessageWithMap) String() string { + if this == nil { + return "nil" + } + keysForNameMapping := make([]int32, 0, len(this.NameMapping)) + for k := range this.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + mapStringForNameMapping := "map[int32]string{" + for _, k := range keysForNameMapping { + mapStringForNameMapping += fmt.Sprintf("%v: %v,", k, this.NameMapping[k]) + } + mapStringForNameMapping += "}" + keysForMsgMapping := make([]int64, 0, len(this.MsgMapping)) + for k := range this.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + mapStringForMsgMapping := "map[int64]*FloatingPoint{" + for _, k := range keysForMsgMapping { + mapStringForMsgMapping += fmt.Sprintf("%v: %v,", k, this.MsgMapping[k]) + } + mapStringForMsgMapping += "}" + keysForByteMapping := make([]bool, 0, len(this.ByteMapping)) + for k := range this.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + mapStringForByteMapping := "map[bool][]byte{" + for _, k := range keysForByteMapping { + mapStringForByteMapping += fmt.Sprintf("%v: %v,", k, this.ByteMapping[k]) + } + mapStringForByteMapping += "}" + s := strings.Join([]string{`&MessageWithMap{`, + `NameMapping:` + mapStringForNameMapping + `,`, + `MsgMapping:` + mapStringForMsgMapping + `,`, + `ByteMapping:` + mapStringForByteMapping + `,`, + `}`, + }, "") + return s +} +func (this *FloatingPoint) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FloatingPoint{`, + `F:` + fmt.Sprintf("%v", this.F) + `,`, + `}`, + }, "") + return s +} +func valueToStringTheproto3(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/neither/theproto3.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/neither/theproto3.proto new file mode 100644 index 0000000000000000000000000000000000000000..8ceec9aad5558f3301207a22efa1879f926dd0d6 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/neither/theproto3.proto @@ -0,0 +1,129 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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 theproto3; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +import "github.com/gogo/protobuf/test/combos/both/thetest.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Message { + enum Humour { + UNKNOWN = 0; + PUNS = 1; + SLAPSTICK = 2; + BILL_BAILEY = 3; + } + + string name = 1; + Humour hilarity = 2; + uint32 height_in_cm = 3; + bytes data = 4; + int64 result_count = 7; + bool true_scotsman = 8; + float score = 9; + + repeated uint64 key = 5; + Nested nested = 6; + + map terrain = 10; + test.NinOptNative proto2_field = 11; + map proto2_value = 13; +} + +message Nested { + string bunny = 1; +} + +enum MapEnum { + MA = 0; + MB = 1; + MC = 2; +} + +message AllMaps { + map StringToDoubleMap = 1; + map StringToFloatMap = 2; + map Int32Map = 3; + map Int64Map = 4; + map Uint32Map = 5; + map Uint64Map = 6; + map Sint32Map = 7; + map Sint64Map = 8; + map Fixed32Map = 9; + map Sfixed32Map = 10; + map Fixed64Map = 11; + map Sfixed64Map = 12; + map BoolMap = 13; + map StringMap = 14; + map StringToBytesMap = 15; + map StringToEnumMap = 16; + map StringToMsgMap = 17; +} + +message MessageWithMap { + map name_mapping = 1; + map msg_mapping = 2; + map byte_mapping = 3; +} + +message FloatingPoint { + double f = 1; +} \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/neither/theproto3pb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/neither/theproto3pb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..93edde85d4b272397ceb68a261032d0c163f4355 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/neither/theproto3pb_test.go @@ -0,0 +1,1092 @@ +// Code generated by protoc-gen-gogo. +// source: combos/neither/theproto3.proto +// DO NOT EDIT! + +/* +Package theproto3 is a generated protocol buffer package. + +It is generated from these files: + combos/neither/theproto3.proto + +It has these top-level messages: + Message + Nested + AllMaps + MessageWithMap + FloatingPoint +*/ +package theproto3 + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" +// discarding unused import test "github.com/gogo/protobuf/test/combos/both" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestMessageProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkMessageProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Message, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMessageProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessage(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Message{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNestedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nested, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNested(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNested(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Nested{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAllMapsProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMaps(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AllMaps{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageWithMapProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkMessageWithMapProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MessageWithMap, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMessageWithMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMessageWithMapProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessageWithMap(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &MessageWithMap{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkFloatingPointProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedFloatingPoint(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &FloatingPoint{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllMapsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMessageWithMapJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestFloatingPointJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMessageProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Message{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Message{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageWithMapProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageWithMapProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTheproto3Description(t *testing.T) { + Theproto3Description() +} +func TestMessageVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllMapsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMessageWithMapVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestFloatingPointVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMessageFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAllMapsFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestMessageWithMapFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestFloatingPointFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestMessageGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllMapsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMessageWithMapGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestFloatingPointGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMessageSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMessageSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Message, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nested, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNested(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAllMapsSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageWithMapSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMessageWithMapSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MessageWithMap, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMessageWithMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkFloatingPointSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllMapsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestMessageWithMapStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestFloatingPointStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unmarshaler/nilmaps_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unmarshaler/nilmaps_test.go new file mode 100644 index 0000000000000000000000000000000000000000..1b05c72b2c453fe78cac35296c395d0dc5951bc8 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unmarshaler/nilmaps_test.go @@ -0,0 +1,39 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 theproto3 + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "testing" +) + +func TestNilMaps(t *testing.T) { + m := &AllMaps{StringToMsgMap: map[string]*FloatingPoint{"a": nil}} + if _, err := proto.Marshal(m); err == nil { + t.Fatalf("expected error") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unmarshaler/theproto3.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unmarshaler/theproto3.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..e4e7859b22b30b251f19b87fc59e0dc47cae4c36 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unmarshaler/theproto3.pb.go @@ -0,0 +1,10365 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unmarshaler/theproto3.proto +// DO NOT EDIT! + +/* + Package theproto3 is a generated protocol buffer package. + + It is generated from these files: + combos/unmarshaler/theproto3.proto + + It has these top-level messages: + Message + Nested + AllMaps + MessageWithMap + FloatingPoint +*/ +package theproto3 + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" +import test "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" +import github_com_gogo_protobuf_sortkeys "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/sortkeys" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type MapEnum int32 + +const ( + MA MapEnum = 0 + MB MapEnum = 1 + MC MapEnum = 2 +) + +var MapEnum_name = map[int32]string{ + 0: "MA", + 1: "MB", + 2: "MC", +} +var MapEnum_value = map[string]int32{ + "MA": 0, + "MB": 1, + "MC": 2, +} + +type Message_Humour int32 + +const ( + UNKNOWN Message_Humour = 0 + PUNS Message_Humour = 1 + SLAPSTICK Message_Humour = 2 + BILL_BAILEY Message_Humour = 3 +) + +var Message_Humour_name = map[int32]string{ + 0: "UNKNOWN", + 1: "PUNS", + 2: "SLAPSTICK", + 3: "BILL_BAILEY", +} +var Message_Humour_value = map[string]int32{ + "UNKNOWN": 0, + "PUNS": 1, + "SLAPSTICK": 2, + "BILL_BAILEY": 3, +} + +type Message struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Hilarity Message_Humour `protobuf:"varint,2,opt,name=hilarity,proto3,enum=theproto3.Message_Humour" json:"hilarity,omitempty"` + HeightInCm uint32 `protobuf:"varint,3,opt,name=height_in_cm,proto3" json:"height_in_cm,omitempty"` + Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` + ResultCount int64 `protobuf:"varint,7,opt,name=result_count,proto3" json:"result_count,omitempty"` + TrueScotsman bool `protobuf:"varint,8,opt,name=true_scotsman,proto3" json:"true_scotsman,omitempty"` + Score float32 `protobuf:"fixed32,9,opt,name=score,proto3" json:"score,omitempty"` + Key []uint64 `protobuf:"varint,5,rep,name=key" json:"key,omitempty"` + Nested *Nested `protobuf:"bytes,6,opt,name=nested" json:"nested,omitempty"` + Terrain map[int64]*Nested `protobuf:"bytes,10,rep,name=terrain" json:"terrain,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` + Proto2Field *test.NinOptNative `protobuf:"bytes,11,opt,name=proto2_field" json:"proto2_field,omitempty"` + Proto2Value map[int64]*test.NinOptEnum `protobuf:"bytes,13,rep,name=proto2_value" json:"proto2_value,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` +} + +func (m *Message) Reset() { *m = Message{} } +func (*Message) ProtoMessage() {} + +type Nested struct { + Bunny string `protobuf:"bytes,1,opt,name=bunny,proto3" json:"bunny,omitempty"` +} + +func (m *Nested) Reset() { *m = Nested{} } +func (*Nested) ProtoMessage() {} + +type AllMaps struct { + StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key,proto3" protobuf_val:"zigzag32,2,opt,name=value,proto3"` + Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"` + Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=theproto3.MapEnum"` + StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` +} + +func (m *AllMaps) Reset() { *m = AllMaps{} } +func (*AllMaps) ProtoMessage() {} + +type MessageWithMap struct { + NameMapping map[int32]string `protobuf:"bytes,1,rep,name=name_mapping" json:"name_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + MsgMapping map[int64]*FloatingPoint `protobuf:"bytes,2,rep,name=msg_mapping" json:"msg_mapping,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` + ByteMapping map[bool][]byte `protobuf:"bytes,3,rep,name=byte_mapping" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (m *MessageWithMap) Reset() { *m = MessageWithMap{} } +func (*MessageWithMap) ProtoMessage() {} + +type FloatingPoint struct { + F float64 `protobuf:"fixed64,1,opt,name=f,proto3" json:"f,omitempty"` +} + +func (m *FloatingPoint) Reset() { *m = FloatingPoint{} } +func (*FloatingPoint) ProtoMessage() {} + +func init() { + proto.RegisterEnum("theproto3.MapEnum", MapEnum_name, MapEnum_value) + proto.RegisterEnum("theproto3.Message_Humour", Message_Humour_name, Message_Humour_value) +} +func (this *Message) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *Nested) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *AllMaps) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *MessageWithMap) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *FloatingPoint) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func Theproto3Description() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/test/combos/both/thetest.proto"), + Package: func(v string) *string { return &v }("test"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NinRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NidOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }, {Name: func(v string) *string { return &v }("NidNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidRepStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStruct"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinRepStruct"), + }}, + }, {Name: func(v string) *string { return &v }("NidOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomDash"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x64, 0x61, 0x73, 0x68, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NidRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinOptStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinNestedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNativeUnion"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStructUnion"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStructUnion"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Tree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Or"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.OrBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Leaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("OrBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Leaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("StrValue"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepTree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.ADeepBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndDeepBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepLeaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("ADeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndDeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepLeaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Tree"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Nil")}, {Name: func(v string) *string { return &v }("NidOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NidRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + DefaultValue: func(v string) *string { return &v }("C"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + DefaultValue: func(v string) *string { return &v }("E"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Timer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Time1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Time2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Data"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("MyExtendable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("OtherExtenable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("M"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(14), + End: func(v int32) *int32 { return &v }(17), + }, {Start: func(v int32) *int32 { return &v }(10), + End: func(v int32) *int32 { return &v }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("NestedDefinition"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("EnumField"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("NM"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedMessage"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedField1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedMsg"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedField1"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("NestedEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_NESTED"), + Number: func(v int32) *int32 { return &v }(1), + }}, + }}, + }, {Name: func(v string) *string { return &v }("NestedScope"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("true"), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("CustomContainer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("CustomStruct"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptCustom"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x5, 0x46, 0x69, 0x65, 0x6c, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameCustomType"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Ids"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Values"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("CustomNameEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + }, {Name: func(v string) *string { return &v }("NoExtensionsMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0}), 64025: proto.NewExtension([]byte{0xc8, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Unrecognized"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithInner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithInner.Inner"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Inner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithEmbed"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithEmbed.Embedded"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Embedded"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("TheTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }, {Name: func(v string) *string { return &v }("AnotherTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("D"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("E"), + Number: func(v int32) *int32 { return &v }(11), + }}, + Options: &google_protobuf.EnumOptions{XXX_extensions: map[int32]proto.Extension{62001: proto.NewExtension([]byte{0x88, 0xa3, 0x1e, 0x0})}}, + }}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("FieldA"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldB"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldC"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldA1"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldB1"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldC1"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }, {Name: func(v string) *string { return &v }("combos/unmarshaler/theproto3.proto"), + Package: func(v string) *string { return &v }("theproto3"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto", "github.com/gogo/protobuf/test/combos/both/thetest.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Message"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("hilarity"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".theproto3.Message.Humour"), + }, {Name: func(v string) *string { return &v }("height_in_cm"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("data"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("result_count"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("true_scotsman"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("score"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("nested"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Nested"), + }, {Name: func(v string) *string { return &v }("terrain"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Message.TerrainEntry"), + }, {Name: func(v string) *string { return &v }("proto2_field"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("proto2_value"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Message.Proto2ValueEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("TerrainEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Nested"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Proto2ValueEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Humour"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("UNKNOWN"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("PUNS"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("SLAPSTICK"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("BILL_BAILEY"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("Nested"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("bunny"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("AllMaps"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMap"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToDoubleMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToFloatMap"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToFloatMapEntry"), + }, {Name: func(v string) *string { return &v }("Int32Map"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Int32MapEntry"), + }, {Name: func(v string) *string { return &v }("Int64Map"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Int64MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint32Map"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Uint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint64Map"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Uint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint32Map"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint64Map"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed32Map"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Fixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed32Map"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sfixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed64Map"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Fixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed64Map"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sfixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("BoolMap"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.BoolMapEntry"), + }, {Name: func(v string) *string { return &v }("StringMap"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToBytesMap"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToBytesMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToEnumMap"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToEnumMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToMsgMap"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToMsgMapEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToFloatMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("BoolMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToBytesMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToEnumMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".theproto3.MapEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToMsgMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("MessageWithMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_mapping"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.NameMappingEntry"), + }, {Name: func(v string) *string { return &v }("msg_mapping"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.MsgMappingEntry"), + }, {Name: func(v string) *string { return &v }("byte_mapping"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.ByteMappingEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NameMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("MsgMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("ByteMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("FloatingPoint"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("f"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("MapEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("MA"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("MB"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("MC"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + Syntax: func(v string) *string { return &v }("proto3"), + }}, + } +} +func (x MapEnum) String() string { + s, ok := MapEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x Message_Humour) String() string { + s, ok := Message_Humour_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *Message) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Message) + if !ok { + return fmt.Errorf("that is not of type *Message") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Message but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Messagebut is not nil && this == nil") + } + if this.Name != that1.Name { + return fmt.Errorf("Name this(%v) Not Equal that(%v)", this.Name, that1.Name) + } + if this.Hilarity != that1.Hilarity { + return fmt.Errorf("Hilarity this(%v) Not Equal that(%v)", this.Hilarity, that1.Hilarity) + } + if this.HeightInCm != that1.HeightInCm { + return fmt.Errorf("HeightInCm this(%v) Not Equal that(%v)", this.HeightInCm, that1.HeightInCm) + } + if !bytes.Equal(this.Data, that1.Data) { + return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data) + } + if this.ResultCount != that1.ResultCount { + return fmt.Errorf("ResultCount this(%v) Not Equal that(%v)", this.ResultCount, that1.ResultCount) + } + if this.TrueScotsman != that1.TrueScotsman { + return fmt.Errorf("TrueScotsman this(%v) Not Equal that(%v)", this.TrueScotsman, that1.TrueScotsman) + } + if this.Score != that1.Score { + return fmt.Errorf("Score this(%v) Not Equal that(%v)", this.Score, that1.Score) + } + if len(this.Key) != len(that1.Key) { + return fmt.Errorf("Key this(%v) Not Equal that(%v)", len(this.Key), len(that1.Key)) + } + for i := range this.Key { + if this.Key[i] != that1.Key[i] { + return fmt.Errorf("Key this[%v](%v) Not Equal that[%v](%v)", i, this.Key[i], i, that1.Key[i]) + } + } + if !this.Nested.Equal(that1.Nested) { + return fmt.Errorf("Nested this(%v) Not Equal that(%v)", this.Nested, that1.Nested) + } + if len(this.Terrain) != len(that1.Terrain) { + return fmt.Errorf("Terrain this(%v) Not Equal that(%v)", len(this.Terrain), len(that1.Terrain)) + } + for i := range this.Terrain { + if !this.Terrain[i].Equal(that1.Terrain[i]) { + return fmt.Errorf("Terrain this[%v](%v) Not Equal that[%v](%v)", i, this.Terrain[i], i, that1.Terrain[i]) + } + } + if !this.Proto2Field.Equal(that1.Proto2Field) { + return fmt.Errorf("Proto2Field this(%v) Not Equal that(%v)", this.Proto2Field, that1.Proto2Field) + } + if len(this.Proto2Value) != len(that1.Proto2Value) { + return fmt.Errorf("Proto2Value this(%v) Not Equal that(%v)", len(this.Proto2Value), len(that1.Proto2Value)) + } + for i := range this.Proto2Value { + if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) { + return fmt.Errorf("Proto2Value this[%v](%v) Not Equal that[%v](%v)", i, this.Proto2Value[i], i, that1.Proto2Value[i]) + } + } + return nil +} +func (this *Message) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Message) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Name != that1.Name { + return false + } + if this.Hilarity != that1.Hilarity { + return false + } + if this.HeightInCm != that1.HeightInCm { + return false + } + if !bytes.Equal(this.Data, that1.Data) { + return false + } + if this.ResultCount != that1.ResultCount { + return false + } + if this.TrueScotsman != that1.TrueScotsman { + return false + } + if this.Score != that1.Score { + return false + } + if len(this.Key) != len(that1.Key) { + return false + } + for i := range this.Key { + if this.Key[i] != that1.Key[i] { + return false + } + } + if !this.Nested.Equal(that1.Nested) { + return false + } + if len(this.Terrain) != len(that1.Terrain) { + return false + } + for i := range this.Terrain { + if !this.Terrain[i].Equal(that1.Terrain[i]) { + return false + } + } + if !this.Proto2Field.Equal(that1.Proto2Field) { + return false + } + if len(this.Proto2Value) != len(that1.Proto2Value) { + return false + } + for i := range this.Proto2Value { + if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) { + return false + } + } + return true +} +func (this *Nested) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Nested) + if !ok { + return fmt.Errorf("that is not of type *Nested") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Nested but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Nestedbut is not nil && this == nil") + } + if this.Bunny != that1.Bunny { + return fmt.Errorf("Bunny this(%v) Not Equal that(%v)", this.Bunny, that1.Bunny) + } + return nil +} +func (this *Nested) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Nested) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Bunny != that1.Bunny { + return false + } + return true +} +func (this *AllMaps) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllMaps) + if !ok { + return fmt.Errorf("that is not of type *AllMaps") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllMaps but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllMapsbut is not nil && this == nil") + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap)) + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i]) + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap)) + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i]) + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map)) + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i]) + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map)) + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i]) + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map)) + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i]) + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map)) + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i]) + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map)) + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i]) + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map)) + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i]) + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map)) + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i]) + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map)) + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i]) + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map)) + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i]) + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map)) + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i]) + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap)) + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i]) + } + } + if len(this.StringMap) != len(that1.StringMap) { + return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap)) + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i]) + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap)) + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i]) + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap)) + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i]) + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap)) + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i]) + } + } + return nil +} +func (this *AllMaps) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllMaps) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return false + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return false + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return false + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return false + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return false + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return false + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return false + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return false + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return false + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return false + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return false + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return false + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return false + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return false + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return false + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return false + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return false + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return false + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return false + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return false + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return false + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return false + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return false + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return false + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return false + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return false + } + } + if len(this.StringMap) != len(that1.StringMap) { + return false + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return false + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return false + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return false + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return false + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return false + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return false + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return false + } + } + return true +} +func (this *MessageWithMap) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*MessageWithMap) + if !ok { + return fmt.Errorf("that is not of type *MessageWithMap") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *MessageWithMap but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *MessageWithMapbut is not nil && this == nil") + } + if len(this.NameMapping) != len(that1.NameMapping) { + return fmt.Errorf("NameMapping this(%v) Not Equal that(%v)", len(this.NameMapping), len(that1.NameMapping)) + } + for i := range this.NameMapping { + if this.NameMapping[i] != that1.NameMapping[i] { + return fmt.Errorf("NameMapping this[%v](%v) Not Equal that[%v](%v)", i, this.NameMapping[i], i, that1.NameMapping[i]) + } + } + if len(this.MsgMapping) != len(that1.MsgMapping) { + return fmt.Errorf("MsgMapping this(%v) Not Equal that(%v)", len(this.MsgMapping), len(that1.MsgMapping)) + } + for i := range this.MsgMapping { + if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) { + return fmt.Errorf("MsgMapping this[%v](%v) Not Equal that[%v](%v)", i, this.MsgMapping[i], i, that1.MsgMapping[i]) + } + } + if len(this.ByteMapping) != len(that1.ByteMapping) { + return fmt.Errorf("ByteMapping this(%v) Not Equal that(%v)", len(this.ByteMapping), len(that1.ByteMapping)) + } + for i := range this.ByteMapping { + if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) { + return fmt.Errorf("ByteMapping this[%v](%v) Not Equal that[%v](%v)", i, this.ByteMapping[i], i, that1.ByteMapping[i]) + } + } + return nil +} +func (this *MessageWithMap) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*MessageWithMap) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.NameMapping) != len(that1.NameMapping) { + return false + } + for i := range this.NameMapping { + if this.NameMapping[i] != that1.NameMapping[i] { + return false + } + } + if len(this.MsgMapping) != len(that1.MsgMapping) { + return false + } + for i := range this.MsgMapping { + if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) { + return false + } + } + if len(this.ByteMapping) != len(that1.ByteMapping) { + return false + } + for i := range this.ByteMapping { + if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) { + return false + } + } + return true +} +func (this *FloatingPoint) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return fmt.Errorf("that is not of type *FloatingPoint") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *FloatingPointbut is not nil && this == nil") + } + if this.F != that1.F { + return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F) + } + return nil +} +func (this *FloatingPoint) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.F != that1.F { + return false + } + return true +} + +type MessageFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetName() string + GetHilarity() Message_Humour + GetHeightInCm() uint32 + GetData() []byte + GetResultCount() int64 + GetTrueScotsman() bool + GetScore() float32 + GetKey() []uint64 + GetNested() *Nested + GetTerrain() map[int64]*Nested + GetProto2Field() *test.NinOptNative + GetProto2Value() map[int64]*test.NinOptEnum +} + +func (this *Message) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Message) TestProto() github_com_gogo_protobuf_proto.Message { + return NewMessageFromFace(this) +} + +func (this *Message) GetName() string { + return this.Name +} + +func (this *Message) GetHilarity() Message_Humour { + return this.Hilarity +} + +func (this *Message) GetHeightInCm() uint32 { + return this.HeightInCm +} + +func (this *Message) GetData() []byte { + return this.Data +} + +func (this *Message) GetResultCount() int64 { + return this.ResultCount +} + +func (this *Message) GetTrueScotsman() bool { + return this.TrueScotsman +} + +func (this *Message) GetScore() float32 { + return this.Score +} + +func (this *Message) GetKey() []uint64 { + return this.Key +} + +func (this *Message) GetNested() *Nested { + return this.Nested +} + +func (this *Message) GetTerrain() map[int64]*Nested { + return this.Terrain +} + +func (this *Message) GetProto2Field() *test.NinOptNative { + return this.Proto2Field +} + +func (this *Message) GetProto2Value() map[int64]*test.NinOptEnum { + return this.Proto2Value +} + +func NewMessageFromFace(that MessageFace) *Message { + this := &Message{} + this.Name = that.GetName() + this.Hilarity = that.GetHilarity() + this.HeightInCm = that.GetHeightInCm() + this.Data = that.GetData() + this.ResultCount = that.GetResultCount() + this.TrueScotsman = that.GetTrueScotsman() + this.Score = that.GetScore() + this.Key = that.GetKey() + this.Nested = that.GetNested() + this.Terrain = that.GetTerrain() + this.Proto2Field = that.GetProto2Field() + this.Proto2Value = that.GetProto2Value() + return this +} + +type NestedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetBunny() string +} + +func (this *Nested) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Nested) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedFromFace(this) +} + +func (this *Nested) GetBunny() string { + return this.Bunny +} + +func NewNestedFromFace(that NestedFace) *Nested { + this := &Nested{} + this.Bunny = that.GetBunny() + return this +} + +type AllMapsFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetStringToDoubleMap() map[string]float64 + GetStringToFloatMap() map[string]float32 + GetInt32Map() map[int32]int32 + GetInt64Map() map[int64]int64 + GetUint32Map() map[uint32]uint32 + GetUint64Map() map[uint64]uint64 + GetSint32Map() map[int32]int32 + GetSint64Map() map[int64]int64 + GetFixed32Map() map[uint32]uint32 + GetSfixed32Map() map[int32]int32 + GetFixed64Map() map[uint64]uint64 + GetSfixed64Map() map[int64]int64 + GetBoolMap() map[bool]bool + GetStringMap() map[string]string + GetStringToBytesMap() map[string][]byte + GetStringToEnumMap() map[string]MapEnum + GetStringToMsgMap() map[string]*FloatingPoint +} + +func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAllMapsFromFace(this) +} + +func (this *AllMaps) GetStringToDoubleMap() map[string]float64 { + return this.StringToDoubleMap +} + +func (this *AllMaps) GetStringToFloatMap() map[string]float32 { + return this.StringToFloatMap +} + +func (this *AllMaps) GetInt32Map() map[int32]int32 { + return this.Int32Map +} + +func (this *AllMaps) GetInt64Map() map[int64]int64 { + return this.Int64Map +} + +func (this *AllMaps) GetUint32Map() map[uint32]uint32 { + return this.Uint32Map +} + +func (this *AllMaps) GetUint64Map() map[uint64]uint64 { + return this.Uint64Map +} + +func (this *AllMaps) GetSint32Map() map[int32]int32 { + return this.Sint32Map +} + +func (this *AllMaps) GetSint64Map() map[int64]int64 { + return this.Sint64Map +} + +func (this *AllMaps) GetFixed32Map() map[uint32]uint32 { + return this.Fixed32Map +} + +func (this *AllMaps) GetSfixed32Map() map[int32]int32 { + return this.Sfixed32Map +} + +func (this *AllMaps) GetFixed64Map() map[uint64]uint64 { + return this.Fixed64Map +} + +func (this *AllMaps) GetSfixed64Map() map[int64]int64 { + return this.Sfixed64Map +} + +func (this *AllMaps) GetBoolMap() map[bool]bool { + return this.BoolMap +} + +func (this *AllMaps) GetStringMap() map[string]string { + return this.StringMap +} + +func (this *AllMaps) GetStringToBytesMap() map[string][]byte { + return this.StringToBytesMap +} + +func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum { + return this.StringToEnumMap +} + +func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint { + return this.StringToMsgMap +} + +func NewAllMapsFromFace(that AllMapsFace) *AllMaps { + this := &AllMaps{} + this.StringToDoubleMap = that.GetStringToDoubleMap() + this.StringToFloatMap = that.GetStringToFloatMap() + this.Int32Map = that.GetInt32Map() + this.Int64Map = that.GetInt64Map() + this.Uint32Map = that.GetUint32Map() + this.Uint64Map = that.GetUint64Map() + this.Sint32Map = that.GetSint32Map() + this.Sint64Map = that.GetSint64Map() + this.Fixed32Map = that.GetFixed32Map() + this.Sfixed32Map = that.GetSfixed32Map() + this.Fixed64Map = that.GetFixed64Map() + this.Sfixed64Map = that.GetSfixed64Map() + this.BoolMap = that.GetBoolMap() + this.StringMap = that.GetStringMap() + this.StringToBytesMap = that.GetStringToBytesMap() + this.StringToEnumMap = that.GetStringToEnumMap() + this.StringToMsgMap = that.GetStringToMsgMap() + return this +} + +type MessageWithMapFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNameMapping() map[int32]string + GetMsgMapping() map[int64]*FloatingPoint + GetByteMapping() map[bool][]byte +} + +func (this *MessageWithMap) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *MessageWithMap) TestProto() github_com_gogo_protobuf_proto.Message { + return NewMessageWithMapFromFace(this) +} + +func (this *MessageWithMap) GetNameMapping() map[int32]string { + return this.NameMapping +} + +func (this *MessageWithMap) GetMsgMapping() map[int64]*FloatingPoint { + return this.MsgMapping +} + +func (this *MessageWithMap) GetByteMapping() map[bool][]byte { + return this.ByteMapping +} + +func NewMessageWithMapFromFace(that MessageWithMapFace) *MessageWithMap { + this := &MessageWithMap{} + this.NameMapping = that.GetNameMapping() + this.MsgMapping = that.GetMsgMapping() + this.ByteMapping = that.GetByteMapping() + return this +} + +type FloatingPointFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetF() float64 +} + +func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message { + return NewFloatingPointFromFace(this) +} + +func (this *FloatingPoint) GetF() float64 { + return this.F +} + +func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint { + this := &FloatingPoint{} + this.F = that.GetF() + return this +} + +func (this *Message) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 16) + s = append(s, "&theproto3.Message{") + s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n") + s = append(s, "Hilarity: "+fmt.Sprintf("%#v", this.Hilarity)+",\n") + s = append(s, "HeightInCm: "+fmt.Sprintf("%#v", this.HeightInCm)+",\n") + s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") + s = append(s, "ResultCount: "+fmt.Sprintf("%#v", this.ResultCount)+",\n") + s = append(s, "TrueScotsman: "+fmt.Sprintf("%#v", this.TrueScotsman)+",\n") + s = append(s, "Score: "+fmt.Sprintf("%#v", this.Score)+",\n") + s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n") + if this.Nested != nil { + s = append(s, "Nested: "+fmt.Sprintf("%#v", this.Nested)+",\n") + } + keysForTerrain := make([]int64, 0, len(this.Terrain)) + for k := range this.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + mapStringForTerrain := "map[int64]*Nested{" + for _, k := range keysForTerrain { + mapStringForTerrain += fmt.Sprintf("%#v: %#v,", k, this.Terrain[k]) + } + mapStringForTerrain += "}" + if this.Terrain != nil { + s = append(s, "Terrain: "+mapStringForTerrain+",\n") + } + if this.Proto2Field != nil { + s = append(s, "Proto2Field: "+fmt.Sprintf("%#v", this.Proto2Field)+",\n") + } + keysForProto2Value := make([]int64, 0, len(this.Proto2Value)) + for k := range this.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + mapStringForProto2Value := "map[int64]*test.NinOptEnum{" + for _, k := range keysForProto2Value { + mapStringForProto2Value += fmt.Sprintf("%#v: %#v,", k, this.Proto2Value[k]) + } + mapStringForProto2Value += "}" + if this.Proto2Value != nil { + s = append(s, "Proto2Value: "+mapStringForProto2Value+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Nested) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&theproto3.Nested{") + s = append(s, "Bunny: "+fmt.Sprintf("%#v", this.Bunny)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllMaps) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 21) + s = append(s, "&theproto3.AllMaps{") + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + if this.StringToDoubleMap != nil { + s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n") + } + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + if this.StringToFloatMap != nil { + s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n") + } + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + if this.Int32Map != nil { + s = append(s, "Int32Map: "+mapStringForInt32Map+",\n") + } + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + if this.Int64Map != nil { + s = append(s, "Int64Map: "+mapStringForInt64Map+",\n") + } + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + if this.Uint32Map != nil { + s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n") + } + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + if this.Uint64Map != nil { + s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n") + } + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + if this.Sint32Map != nil { + s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n") + } + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + if this.Sint64Map != nil { + s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n") + } + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + if this.Fixed32Map != nil { + s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n") + } + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + if this.Sfixed32Map != nil { + s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n") + } + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + if this.Fixed64Map != nil { + s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n") + } + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + if this.Sfixed64Map != nil { + s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n") + } + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + if this.BoolMap != nil { + s = append(s, "BoolMap: "+mapStringForBoolMap+",\n") + } + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + if this.StringMap != nil { + s = append(s, "StringMap: "+mapStringForStringMap+",\n") + } + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + if this.StringToBytesMap != nil { + s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n") + } + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + if this.StringToEnumMap != nil { + s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n") + } + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + if this.StringToMsgMap != nil { + s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MessageWithMap) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&theproto3.MessageWithMap{") + keysForNameMapping := make([]int32, 0, len(this.NameMapping)) + for k := range this.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + mapStringForNameMapping := "map[int32]string{" + for _, k := range keysForNameMapping { + mapStringForNameMapping += fmt.Sprintf("%#v: %#v,", k, this.NameMapping[k]) + } + mapStringForNameMapping += "}" + if this.NameMapping != nil { + s = append(s, "NameMapping: "+mapStringForNameMapping+",\n") + } + keysForMsgMapping := make([]int64, 0, len(this.MsgMapping)) + for k := range this.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + mapStringForMsgMapping := "map[int64]*FloatingPoint{" + for _, k := range keysForMsgMapping { + mapStringForMsgMapping += fmt.Sprintf("%#v: %#v,", k, this.MsgMapping[k]) + } + mapStringForMsgMapping += "}" + if this.MsgMapping != nil { + s = append(s, "MsgMapping: "+mapStringForMsgMapping+",\n") + } + keysForByteMapping := make([]bool, 0, len(this.ByteMapping)) + for k := range this.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + mapStringForByteMapping := "map[bool][]byte{" + for _, k := range keysForByteMapping { + mapStringForByteMapping += fmt.Sprintf("%#v: %#v,", k, this.ByteMapping[k]) + } + mapStringForByteMapping += "}" + if this.ByteMapping != nil { + s = append(s, "ByteMapping: "+mapStringForByteMapping+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FloatingPoint) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&theproto3.FloatingPoint{") + s = append(s, "F: "+fmt.Sprintf("%#v", this.F)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringTheproto3(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringTheproto3(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedMessage(r randyTheproto3, easy bool) *Message { + this := &Message{} + this.Name = randStringTheproto3(r) + this.Hilarity = Message_Humour([]int32{0, 1, 2, 3}[r.Intn(4)]) + this.HeightInCm = uint32(r.Uint32()) + v1 := r.Intn(100) + this.Data = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Data[i] = byte(r.Intn(256)) + } + this.ResultCount = int64(r.Int63()) + if r.Intn(2) == 0 { + this.ResultCount *= -1 + } + this.TrueScotsman = bool(bool(r.Intn(2) == 0)) + this.Score = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Score *= -1 + } + v2 := r.Intn(100) + this.Key = make([]uint64, v2) + for i := 0; i < v2; i++ { + this.Key[i] = uint64(uint64(r.Uint32())) + } + if r.Intn(10) != 0 { + this.Nested = NewPopulatedNested(r, easy) + } + if r.Intn(10) != 0 { + v3 := r.Intn(10) + this.Terrain = make(map[int64]*Nested) + for i := 0; i < v3; i++ { + this.Terrain[int64(r.Int63())] = NewPopulatedNested(r, easy) + } + } + if r.Intn(10) != 0 { + this.Proto2Field = test.NewPopulatedNinOptNative(r, easy) + } + if r.Intn(10) != 0 { + v4 := r.Intn(10) + this.Proto2Value = make(map[int64]*test.NinOptEnum) + for i := 0; i < v4; i++ { + this.Proto2Value[int64(r.Int63())] = test.NewPopulatedNinOptEnum(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedNested(r randyTheproto3, easy bool) *Nested { + this := &Nested{} + this.Bunny = randStringTheproto3(r) + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedAllMaps(r randyTheproto3, easy bool) *AllMaps { + this := &AllMaps{} + if r.Intn(10) != 0 { + v5 := r.Intn(10) + this.StringToDoubleMap = make(map[string]float64) + for i := 0; i < v5; i++ { + v6 := randStringTheproto3(r) + this.StringToDoubleMap[v6] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.StringToDoubleMap[v6] *= -1 + } + } + } + if r.Intn(10) != 0 { + v7 := r.Intn(10) + this.StringToFloatMap = make(map[string]float32) + for i := 0; i < v7; i++ { + v8 := randStringTheproto3(r) + this.StringToFloatMap[v8] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.StringToFloatMap[v8] *= -1 + } + } + } + if r.Intn(10) != 0 { + v9 := r.Intn(10) + this.Int32Map = make(map[int32]int32) + for i := 0; i < v9; i++ { + v10 := int32(r.Int31()) + this.Int32Map[v10] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Int32Map[v10] *= -1 + } + } + } + if r.Intn(10) != 0 { + v11 := r.Intn(10) + this.Int64Map = make(map[int64]int64) + for i := 0; i < v11; i++ { + v12 := int64(r.Int63()) + this.Int64Map[v12] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Int64Map[v12] *= -1 + } + } + } + if r.Intn(10) != 0 { + v13 := r.Intn(10) + this.Uint32Map = make(map[uint32]uint32) + for i := 0; i < v13; i++ { + v14 := uint32(r.Uint32()) + this.Uint32Map[v14] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v15 := r.Intn(10) + this.Uint64Map = make(map[uint64]uint64) + for i := 0; i < v15; i++ { + v16 := uint64(uint64(r.Uint32())) + this.Uint64Map[v16] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v17 := r.Intn(10) + this.Sint32Map = make(map[int32]int32) + for i := 0; i < v17; i++ { + v18 := int32(r.Int31()) + this.Sint32Map[v18] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sint32Map[v18] *= -1 + } + } + } + if r.Intn(10) != 0 { + v19 := r.Intn(10) + this.Sint64Map = make(map[int64]int64) + for i := 0; i < v19; i++ { + v20 := int64(r.Int63()) + this.Sint64Map[v20] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sint64Map[v20] *= -1 + } + } + } + if r.Intn(10) != 0 { + v21 := r.Intn(10) + this.Fixed32Map = make(map[uint32]uint32) + for i := 0; i < v21; i++ { + v22 := uint32(r.Uint32()) + this.Fixed32Map[v22] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v23 := r.Intn(10) + this.Sfixed32Map = make(map[int32]int32) + for i := 0; i < v23; i++ { + v24 := int32(r.Int31()) + this.Sfixed32Map[v24] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sfixed32Map[v24] *= -1 + } + } + } + if r.Intn(10) != 0 { + v25 := r.Intn(10) + this.Fixed64Map = make(map[uint64]uint64) + for i := 0; i < v25; i++ { + v26 := uint64(uint64(r.Uint32())) + this.Fixed64Map[v26] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v27 := r.Intn(10) + this.Sfixed64Map = make(map[int64]int64) + for i := 0; i < v27; i++ { + v28 := int64(r.Int63()) + this.Sfixed64Map[v28] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sfixed64Map[v28] *= -1 + } + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(10) + this.BoolMap = make(map[bool]bool) + for i := 0; i < v29; i++ { + v30 := bool(bool(r.Intn(2) == 0)) + this.BoolMap[v30] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v31 := r.Intn(10) + this.StringMap = make(map[string]string) + for i := 0; i < v31; i++ { + this.StringMap[randStringTheproto3(r)] = randStringTheproto3(r) + } + } + if r.Intn(10) != 0 { + v32 := r.Intn(10) + this.StringToBytesMap = make(map[string][]byte) + for i := 0; i < v32; i++ { + v33 := r.Intn(100) + v34 := randStringTheproto3(r) + this.StringToBytesMap[v34] = make([]byte, v33) + for i := 0; i < v33; i++ { + this.StringToBytesMap[v34][i] = byte(r.Intn(256)) + } + } + } + if r.Intn(10) != 0 { + v35 := r.Intn(10) + this.StringToEnumMap = make(map[string]MapEnum) + for i := 0; i < v35; i++ { + this.StringToEnumMap[randStringTheproto3(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if r.Intn(10) != 0 { + v36 := r.Intn(10) + this.StringToMsgMap = make(map[string]*FloatingPoint) + for i := 0; i < v36; i++ { + this.StringToMsgMap[randStringTheproto3(r)] = NewPopulatedFloatingPoint(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedMessageWithMap(r randyTheproto3, easy bool) *MessageWithMap { + this := &MessageWithMap{} + if r.Intn(10) != 0 { + v37 := r.Intn(10) + this.NameMapping = make(map[int32]string) + for i := 0; i < v37; i++ { + this.NameMapping[int32(r.Int31())] = randStringTheproto3(r) + } + } + if r.Intn(10) != 0 { + v38 := r.Intn(10) + this.MsgMapping = make(map[int64]*FloatingPoint) + for i := 0; i < v38; i++ { + this.MsgMapping[int64(r.Int63())] = NewPopulatedFloatingPoint(r, easy) + } + } + if r.Intn(10) != 0 { + v39 := r.Intn(10) + this.ByteMapping = make(map[bool][]byte) + for i := 0; i < v39; i++ { + v40 := r.Intn(100) + v41 := bool(bool(r.Intn(2) == 0)) + this.ByteMapping[v41] = make([]byte, v40) + for i := 0; i < v40; i++ { + this.ByteMapping[v41][i] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedFloatingPoint(r randyTheproto3, easy bool) *FloatingPoint { + this := &FloatingPoint{} + this.F = float64(r.Float64()) + if r.Intn(2) == 0 { + this.F *= -1 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +type randyTheproto3 interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneTheproto3(r randyTheproto3) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringTheproto3(r randyTheproto3) string { + v42 := r.Intn(100) + tmps := make([]rune, v42) + for i := 0; i < v42; i++ { + tmps[i] = randUTF8RuneTheproto3(r) + } + return string(tmps) +} +func randUnrecognizedTheproto3(r randyTheproto3, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldTheproto3(data, r, fieldNumber, wire) + } + return data +} +func randFieldTheproto3(data []byte, r randyTheproto3, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + v43 := r.Int63() + if r.Intn(2) == 0 { + v43 *= -1 + } + data = encodeVarintPopulateTheproto3(data, uint64(v43)) + case 1: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateTheproto3(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateTheproto3(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Message) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + if m.Hilarity != 0 { + n += 1 + sovTheproto3(uint64(m.Hilarity)) + } + if m.HeightInCm != 0 { + n += 1 + sovTheproto3(uint64(m.HeightInCm)) + } + if m.Data != nil { + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + } + if m.ResultCount != 0 { + n += 1 + sovTheproto3(uint64(m.ResultCount)) + } + if m.TrueScotsman { + n += 2 + } + if m.Score != 0 { + n += 5 + } + if len(m.Key) > 0 { + for _, e := range m.Key { + n += 1 + sovTheproto3(uint64(e)) + } + } + if m.Nested != nil { + l = m.Nested.Size() + n += 1 + l + sovTheproto3(uint64(l)) + } + if len(m.Terrain) > 0 { + for k, v := range m.Terrain { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if m.Proto2Field != nil { + l = m.Proto2Field.Size() + n += 1 + l + sovTheproto3(uint64(l)) + } + if len(m.Proto2Value) > 0 { + for k, v := range m.Proto2Value { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *Nested) Size() (n int) { + var l int + _ = l + l = len(m.Bunny) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + return n +} + +func (m *AllMaps) Size() (n int) { + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + for k, v := range m.StringToDoubleMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToFloatMap) > 0 { + for k, v := range m.StringToFloatMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Int32Map) > 0 { + for k, v := range m.Int32Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Int64Map) > 0 { + for k, v := range m.Int64Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Uint32Map) > 0 { + for k, v := range m.Uint32Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Uint64Map) > 0 { + for k, v := range m.Uint64Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sint32Map) > 0 { + for k, v := range m.Sint32Map { + _ = k + _ = v + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sint64Map) > 0 { + for k, v := range m.Sint64Map { + _ = k + _ = v + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Fixed32Map) > 0 { + for k, v := range m.Fixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sfixed32Map) > 0 { + for k, v := range m.Sfixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Fixed64Map) > 0 { + for k, v := range m.Fixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sfixed64Map) > 0 { + for k, v := range m.Sfixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.BoolMap) > 0 { + for k, v := range m.BoolMap { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + 1 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringMap) > 0 { + for k, v := range m.StringMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToBytesMap) > 0 { + for k, v := range m.StringToBytesMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToEnumMap) > 0 { + for k, v := range m.StringToEnumMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToMsgMap) > 0 { + for k, v := range m.StringToMsgMap { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *MessageWithMap) Size() (n int) { + var l int + _ = l + if len(m.NameMapping) > 0 { + for k, v := range m.NameMapping { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.MsgMapping) > 0 { + for k, v := range m.MsgMapping { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.ByteMapping) > 0 { + for k, v := range m.ByteMapping { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *FloatingPoint) Size() (n int) { + var l int + _ = l + if m.F != 0 { + n += 9 + } + return n +} + +func sovTheproto3(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozTheproto3(x uint64) (n int) { + return sovTheproto3(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Message) String() string { + if this == nil { + return "nil" + } + keysForTerrain := make([]int64, 0, len(this.Terrain)) + for k := range this.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + mapStringForTerrain := "map[int64]*Nested{" + for _, k := range keysForTerrain { + mapStringForTerrain += fmt.Sprintf("%v: %v,", k, this.Terrain[k]) + } + mapStringForTerrain += "}" + keysForProto2Value := make([]int64, 0, len(this.Proto2Value)) + for k := range this.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + mapStringForProto2Value := "map[int64]*test.NinOptEnum{" + for _, k := range keysForProto2Value { + mapStringForProto2Value += fmt.Sprintf("%v: %v,", k, this.Proto2Value[k]) + } + mapStringForProto2Value += "}" + s := strings.Join([]string{`&Message{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Hilarity:` + fmt.Sprintf("%v", this.Hilarity) + `,`, + `HeightInCm:` + fmt.Sprintf("%v", this.HeightInCm) + `,`, + `Data:` + fmt.Sprintf("%v", this.Data) + `,`, + `ResultCount:` + fmt.Sprintf("%v", this.ResultCount) + `,`, + `TrueScotsman:` + fmt.Sprintf("%v", this.TrueScotsman) + `,`, + `Score:` + fmt.Sprintf("%v", this.Score) + `,`, + `Key:` + fmt.Sprintf("%v", this.Key) + `,`, + `Nested:` + strings.Replace(fmt.Sprintf("%v", this.Nested), "Nested", "Nested", 1) + `,`, + `Terrain:` + mapStringForTerrain + `,`, + `Proto2Field:` + strings.Replace(fmt.Sprintf("%v", this.Proto2Field), "NinOptNative", "test.NinOptNative", 1) + `,`, + `Proto2Value:` + mapStringForProto2Value + `,`, + `}`, + }, "") + return s +} +func (this *Nested) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Nested{`, + `Bunny:` + fmt.Sprintf("%v", this.Bunny) + `,`, + `}`, + }, "") + return s +} +func (this *AllMaps) String() string { + if this == nil { + return "nil" + } + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + s := strings.Join([]string{`&AllMaps{`, + `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`, + `StringToFloatMap:` + mapStringForStringToFloatMap + `,`, + `Int32Map:` + mapStringForInt32Map + `,`, + `Int64Map:` + mapStringForInt64Map + `,`, + `Uint32Map:` + mapStringForUint32Map + `,`, + `Uint64Map:` + mapStringForUint64Map + `,`, + `Sint32Map:` + mapStringForSint32Map + `,`, + `Sint64Map:` + mapStringForSint64Map + `,`, + `Fixed32Map:` + mapStringForFixed32Map + `,`, + `Sfixed32Map:` + mapStringForSfixed32Map + `,`, + `Fixed64Map:` + mapStringForFixed64Map + `,`, + `Sfixed64Map:` + mapStringForSfixed64Map + `,`, + `BoolMap:` + mapStringForBoolMap + `,`, + `StringMap:` + mapStringForStringMap + `,`, + `StringToBytesMap:` + mapStringForStringToBytesMap + `,`, + `StringToEnumMap:` + mapStringForStringToEnumMap + `,`, + `StringToMsgMap:` + mapStringForStringToMsgMap + `,`, + `}`, + }, "") + return s +} +func (this *MessageWithMap) String() string { + if this == nil { + return "nil" + } + keysForNameMapping := make([]int32, 0, len(this.NameMapping)) + for k := range this.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + mapStringForNameMapping := "map[int32]string{" + for _, k := range keysForNameMapping { + mapStringForNameMapping += fmt.Sprintf("%v: %v,", k, this.NameMapping[k]) + } + mapStringForNameMapping += "}" + keysForMsgMapping := make([]int64, 0, len(this.MsgMapping)) + for k := range this.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + mapStringForMsgMapping := "map[int64]*FloatingPoint{" + for _, k := range keysForMsgMapping { + mapStringForMsgMapping += fmt.Sprintf("%v: %v,", k, this.MsgMapping[k]) + } + mapStringForMsgMapping += "}" + keysForByteMapping := make([]bool, 0, len(this.ByteMapping)) + for k := range this.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + mapStringForByteMapping := "map[bool][]byte{" + for _, k := range keysForByteMapping { + mapStringForByteMapping += fmt.Sprintf("%v: %v,", k, this.ByteMapping[k]) + } + mapStringForByteMapping += "}" + s := strings.Join([]string{`&MessageWithMap{`, + `NameMapping:` + mapStringForNameMapping + `,`, + `MsgMapping:` + mapStringForMsgMapping + `,`, + `ByteMapping:` + mapStringForByteMapping + `,`, + `}`, + }, "") + return s +} +func (this *FloatingPoint) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FloatingPoint{`, + `F:` + fmt.Sprintf("%v", this.F) + `,`, + `}`, + }, "") + return s +} +func valueToStringTheproto3(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Message) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Message: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Message: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Hilarity", wireType) + } + m.Hilarity = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Hilarity |= (Message_Humour(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field HeightInCm", wireType) + } + m.HeightInCm = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.HeightInCm |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ResultCount", wireType) + } + m.ResultCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ResultCount |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TrueScotsman", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TrueScotsman = bool(v != 0) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Score", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + m.Score = float32(math.Float32frombits(v)) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Key = append(m.Key, v) + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Nested", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Nested == nil { + m.Nested = &Nested{} + } + if err := m.Nested.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Terrain", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3 + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3 + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &Nested{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.Terrain == nil { + m.Terrain = make(map[int64]*Nested) + } + m.Terrain[mapkey] = mapvalue + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proto2Field", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Proto2Field == nil { + m.Proto2Field = &test.NinOptNative{} + } + if err := m.Proto2Field.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proto2Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3 + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3 + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &test.NinOptEnum{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.Proto2Value == nil { + m.Proto2Value = make(map[int64]*test.NinOptEnum) + } + m.Proto2Value[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTheproto3(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Nested) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Nested: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Nested: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Bunny", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Bunny = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTheproto3(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AllMaps) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AllMaps: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AllMaps: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvaluetemp = uint64(data[iNdEx-8]) + mapvaluetemp |= uint64(data[iNdEx-7]) << 8 + mapvaluetemp |= uint64(data[iNdEx-6]) << 16 + mapvaluetemp |= uint64(data[iNdEx-5]) << 24 + mapvaluetemp |= uint64(data[iNdEx-4]) << 32 + mapvaluetemp |= uint64(data[iNdEx-3]) << 40 + mapvaluetemp |= uint64(data[iNdEx-2]) << 48 + mapvaluetemp |= uint64(data[iNdEx-1]) << 56 + mapvalue := math.Float64frombits(mapvaluetemp) + if m.StringToDoubleMap == nil { + m.StringToDoubleMap = make(map[string]float64) + } + m.StringToDoubleMap[mapkey] = mapvalue + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvaluetemp = uint32(data[iNdEx-4]) + mapvaluetemp |= uint32(data[iNdEx-3]) << 8 + mapvaluetemp |= uint32(data[iNdEx-2]) << 16 + mapvaluetemp |= uint32(data[iNdEx-1]) << 24 + mapvalue := math.Float32frombits(mapvaluetemp) + if m.StringToFloatMap == nil { + m.StringToFloatMap = make(map[string]float32) + } + m.StringToFloatMap[mapkey] = mapvalue + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Int32Map == nil { + m.Int32Map = make(map[int32]int32) + } + m.Int32Map[mapkey] = mapvalue + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Int64Map == nil { + m.Int64Map = make(map[int64]int64) + } + m.Int64Map[mapkey] = mapvalue + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Uint32Map == nil { + m.Uint32Map = make(map[uint32]uint32) + } + m.Uint32Map[mapkey] = mapvalue + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Uint64Map == nil { + m.Uint64Map = make(map[uint64]uint64) + } + m.Uint64Map[mapkey] = mapvalue + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31)) + mapkey := int32(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31)) + mapvalue := int32(mapvaluetemp) + if m.Sint32Map == nil { + m.Sint32Map = make(map[int32]int32) + } + m.Sint32Map[mapkey] = mapvalue + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63) + mapkey := int64(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63) + mapvalue := int64(mapvaluetemp) + if m.Sint64Map == nil { + m.Sint64Map = make(map[int64]int64) + } + m.Sint64Map[mapkey] = mapvalue + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapkey = uint32(data[iNdEx-4]) + mapkey |= uint32(data[iNdEx-3]) << 8 + mapkey |= uint32(data[iNdEx-2]) << 16 + mapkey |= uint32(data[iNdEx-1]) << 24 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvalue = uint32(data[iNdEx-4]) + mapvalue |= uint32(data[iNdEx-3]) << 8 + mapvalue |= uint32(data[iNdEx-2]) << 16 + mapvalue |= uint32(data[iNdEx-1]) << 24 + if m.Fixed32Map == nil { + m.Fixed32Map = make(map[uint32]uint32) + } + m.Fixed32Map[mapkey] = mapvalue + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapkey = int32(data[iNdEx-4]) + mapkey |= int32(data[iNdEx-3]) << 8 + mapkey |= int32(data[iNdEx-2]) << 16 + mapkey |= int32(data[iNdEx-1]) << 24 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvalue = int32(data[iNdEx-4]) + mapvalue |= int32(data[iNdEx-3]) << 8 + mapvalue |= int32(data[iNdEx-2]) << 16 + mapvalue |= int32(data[iNdEx-1]) << 24 + if m.Sfixed32Map == nil { + m.Sfixed32Map = make(map[int32]int32) + } + m.Sfixed32Map[mapkey] = mapvalue + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapkey = uint64(data[iNdEx-8]) + mapkey |= uint64(data[iNdEx-7]) << 8 + mapkey |= uint64(data[iNdEx-6]) << 16 + mapkey |= uint64(data[iNdEx-5]) << 24 + mapkey |= uint64(data[iNdEx-4]) << 32 + mapkey |= uint64(data[iNdEx-3]) << 40 + mapkey |= uint64(data[iNdEx-2]) << 48 + mapkey |= uint64(data[iNdEx-1]) << 56 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvalue = uint64(data[iNdEx-8]) + mapvalue |= uint64(data[iNdEx-7]) << 8 + mapvalue |= uint64(data[iNdEx-6]) << 16 + mapvalue |= uint64(data[iNdEx-5]) << 24 + mapvalue |= uint64(data[iNdEx-4]) << 32 + mapvalue |= uint64(data[iNdEx-3]) << 40 + mapvalue |= uint64(data[iNdEx-2]) << 48 + mapvalue |= uint64(data[iNdEx-1]) << 56 + if m.Fixed64Map == nil { + m.Fixed64Map = make(map[uint64]uint64) + } + m.Fixed64Map[mapkey] = mapvalue + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapkey = int64(data[iNdEx-8]) + mapkey |= int64(data[iNdEx-7]) << 8 + mapkey |= int64(data[iNdEx-6]) << 16 + mapkey |= int64(data[iNdEx-5]) << 24 + mapkey |= int64(data[iNdEx-4]) << 32 + mapkey |= int64(data[iNdEx-3]) << 40 + mapkey |= int64(data[iNdEx-2]) << 48 + mapkey |= int64(data[iNdEx-1]) << 56 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvalue = int64(data[iNdEx-8]) + mapvalue |= int64(data[iNdEx-7]) << 8 + mapvalue |= int64(data[iNdEx-6]) << 16 + mapvalue |= int64(data[iNdEx-5]) << 24 + mapvalue |= int64(data[iNdEx-4]) << 32 + mapvalue |= int64(data[iNdEx-3]) << 40 + mapvalue |= int64(data[iNdEx-2]) << 48 + mapvalue |= int64(data[iNdEx-1]) << 56 + if m.Sfixed64Map == nil { + m.Sfixed64Map = make(map[int64]int64) + } + m.Sfixed64Map[mapkey] = mapvalue + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkey := bool(mapkeytemp != 0) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvalue := bool(mapvaluetemp != 0) + if m.BoolMap == nil { + m.BoolMap = make(map[bool]bool) + } + m.BoolMap[mapkey] = mapvalue + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthTheproto3 + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue := string(data[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + if m.StringMap == nil { + m.StringMap = make(map[string]string) + } + m.StringMap[mapkey] = mapvalue + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapbyteLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthTheproto3 + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := make([]byte, mapbyteLen) + copy(mapvalue, data[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + if m.StringToBytesMap == nil { + m.StringToBytesMap = make(map[string][]byte) + } + m.StringToBytesMap[mapkey] = mapvalue + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue MapEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (MapEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.StringToEnumMap == nil { + m.StringToEnumMap = make(map[string]MapEnum) + } + m.StringToEnumMap[mapkey] = mapvalue + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3 + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3 + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3 + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &FloatingPoint{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.StringToMsgMap == nil { + m.StringToMsgMap = make(map[string]*FloatingPoint) + } + m.StringToMsgMap[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTheproto3(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MessageWithMap) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MessageWithMap: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MessageWithMap: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NameMapping", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthTheproto3 + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue := string(data[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + if m.NameMapping == nil { + m.NameMapping = make(map[int32]string) + } + m.NameMapping[mapkey] = mapvalue + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MsgMapping", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63) + mapkey := int64(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3 + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3 + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &FloatingPoint{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.MsgMapping == nil { + m.MsgMapping = make(map[int64]*FloatingPoint) + } + m.MsgMapping[mapkey] = mapvalue + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ByteMapping", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3 + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkey := bool(mapkeytemp != 0) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapbyteLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthTheproto3 + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := make([]byte, mapbyteLen) + copy(mapvalue, data[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + if m.ByteMapping == nil { + m.ByteMapping = make(map[bool][]byte) + } + m.ByteMapping[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTheproto3(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FloatingPoint) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FloatingPoint: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FloatingPoint: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field F", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + m.F = float64(math.Float64frombits(v)) + default: + iNdEx = preIndex + skippy, err := skipTheproto3(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTheproto3(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthTheproto3 + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTheproto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipTheproto3(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthTheproto3 = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTheproto3 = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unmarshaler/theproto3.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unmarshaler/theproto3.proto new file mode 100644 index 0000000000000000000000000000000000000000..3b3dd59c61df30e83d3e48fc8c7f75ac23186a51 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unmarshaler/theproto3.proto @@ -0,0 +1,129 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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 theproto3; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +import "github.com/gogo/protobuf/test/combos/both/thetest.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Message { + enum Humour { + UNKNOWN = 0; + PUNS = 1; + SLAPSTICK = 2; + BILL_BAILEY = 3; + } + + string name = 1; + Humour hilarity = 2; + uint32 height_in_cm = 3; + bytes data = 4; + int64 result_count = 7; + bool true_scotsman = 8; + float score = 9; + + repeated uint64 key = 5; + Nested nested = 6; + + map terrain = 10; + test.NinOptNative proto2_field = 11; + map proto2_value = 13; +} + +message Nested { + string bunny = 1; +} + +enum MapEnum { + MA = 0; + MB = 1; + MC = 2; +} + +message AllMaps { + map StringToDoubleMap = 1; + map StringToFloatMap = 2; + map Int32Map = 3; + map Int64Map = 4; + map Uint32Map = 5; + map Uint64Map = 6; + map Sint32Map = 7; + map Sint64Map = 8; + map Fixed32Map = 9; + map Sfixed32Map = 10; + map Fixed64Map = 11; + map Sfixed64Map = 12; + map BoolMap = 13; + map StringMap = 14; + map StringToBytesMap = 15; + map StringToEnumMap = 16; + map StringToMsgMap = 17; +} + +message MessageWithMap { + map name_mapping = 1; + map msg_mapping = 2; + map byte_mapping = 3; +} + +message FloatingPoint { + double f = 1; +} \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unmarshaler/theproto3pb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unmarshaler/theproto3pb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..1262e3427478eb72adb130841b587c9d881e1031 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unmarshaler/theproto3pb_test.go @@ -0,0 +1,1092 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unmarshaler/theproto3.proto +// DO NOT EDIT! + +/* +Package theproto3 is a generated protocol buffer package. + +It is generated from these files: + combos/unmarshaler/theproto3.proto + +It has these top-level messages: + Message + Nested + AllMaps + MessageWithMap + FloatingPoint +*/ +package theproto3 + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" +// discarding unused import test "github.com/gogo/protobuf/test/combos/both" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestMessageProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkMessageProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Message, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMessageProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessage(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Message{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNestedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nested, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNested(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNested(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Nested{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAllMapsProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMaps(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AllMaps{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageWithMapProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkMessageWithMapProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MessageWithMap, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMessageWithMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMessageWithMapProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessageWithMap(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &MessageWithMap{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkFloatingPointProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedFloatingPoint(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &FloatingPoint{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllMapsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMessageWithMapJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestFloatingPointJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMessageProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Message{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Message{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageWithMapProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageWithMapProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTheproto3Description(t *testing.T) { + Theproto3Description() +} +func TestMessageVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllMapsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMessageWithMapVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestFloatingPointVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMessageFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAllMapsFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestMessageWithMapFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestFloatingPointFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestMessageGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllMapsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMessageWithMapGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestFloatingPointGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMessageSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMessageSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Message, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nested, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNested(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAllMapsSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageWithMapSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMessageWithMapSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MessageWithMap, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMessageWithMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkFloatingPointSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllMapsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestMessageWithMapStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestFloatingPointStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeboth/nilmaps_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeboth/nilmaps_test.go new file mode 100644 index 0000000000000000000000000000000000000000..1b05c72b2c453fe78cac35296c395d0dc5951bc8 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeboth/nilmaps_test.go @@ -0,0 +1,39 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 theproto3 + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "testing" +) + +func TestNilMaps(t *testing.T) { + m := &AllMaps{StringToMsgMap: map[string]*FloatingPoint{"a": nil}} + if _, err := proto.Marshal(m); err == nil { + t.Fatalf("expected error") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeboth/theproto3.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeboth/theproto3.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..01d1753bd43430788f583a732d79e68d81a5929b --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeboth/theproto3.pb.go @@ -0,0 +1,11060 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeboth/theproto3.proto +// DO NOT EDIT! + +/* + Package theproto3 is a generated protocol buffer package. + + It is generated from these files: + combos/unsafeboth/theproto3.proto + + It has these top-level messages: + Message + Nested + AllMaps + MessageWithMap + FloatingPoint +*/ +package theproto3 + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" +import test "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" +import github_com_gogo_protobuf_sortkeys "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/sortkeys" + +import unsafe "unsafe" +import errors "errors" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type MapEnum int32 + +const ( + MA MapEnum = 0 + MB MapEnum = 1 + MC MapEnum = 2 +) + +var MapEnum_name = map[int32]string{ + 0: "MA", + 1: "MB", + 2: "MC", +} +var MapEnum_value = map[string]int32{ + "MA": 0, + "MB": 1, + "MC": 2, +} + +type Message_Humour int32 + +const ( + UNKNOWN Message_Humour = 0 + PUNS Message_Humour = 1 + SLAPSTICK Message_Humour = 2 + BILL_BAILEY Message_Humour = 3 +) + +var Message_Humour_name = map[int32]string{ + 0: "UNKNOWN", + 1: "PUNS", + 2: "SLAPSTICK", + 3: "BILL_BAILEY", +} +var Message_Humour_value = map[string]int32{ + "UNKNOWN": 0, + "PUNS": 1, + "SLAPSTICK": 2, + "BILL_BAILEY": 3, +} + +type Message struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Hilarity Message_Humour `protobuf:"varint,2,opt,name=hilarity,proto3,enum=theproto3.Message_Humour" json:"hilarity,omitempty"` + HeightInCm uint32 `protobuf:"varint,3,opt,name=height_in_cm,proto3" json:"height_in_cm,omitempty"` + Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` + ResultCount int64 `protobuf:"varint,7,opt,name=result_count,proto3" json:"result_count,omitempty"` + TrueScotsman bool `protobuf:"varint,8,opt,name=true_scotsman,proto3" json:"true_scotsman,omitempty"` + Score float32 `protobuf:"fixed32,9,opt,name=score,proto3" json:"score,omitempty"` + Key []uint64 `protobuf:"varint,5,rep,name=key" json:"key,omitempty"` + Nested *Nested `protobuf:"bytes,6,opt,name=nested" json:"nested,omitempty"` + Terrain map[int64]*Nested `protobuf:"bytes,10,rep,name=terrain" json:"terrain,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` + Proto2Field *test.NinOptNative `protobuf:"bytes,11,opt,name=proto2_field" json:"proto2_field,omitempty"` + Proto2Value map[int64]*test.NinOptEnum `protobuf:"bytes,13,rep,name=proto2_value" json:"proto2_value,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` +} + +func (m *Message) Reset() { *m = Message{} } +func (*Message) ProtoMessage() {} + +type Nested struct { + Bunny string `protobuf:"bytes,1,opt,name=bunny,proto3" json:"bunny,omitempty"` +} + +func (m *Nested) Reset() { *m = Nested{} } +func (*Nested) ProtoMessage() {} + +type AllMaps struct { + StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key,proto3" protobuf_val:"zigzag32,2,opt,name=value,proto3"` + Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"` + Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=theproto3.MapEnum"` + StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` +} + +func (m *AllMaps) Reset() { *m = AllMaps{} } +func (*AllMaps) ProtoMessage() {} + +type MessageWithMap struct { + NameMapping map[int32]string `protobuf:"bytes,1,rep,name=name_mapping" json:"name_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + MsgMapping map[int64]*FloatingPoint `protobuf:"bytes,2,rep,name=msg_mapping" json:"msg_mapping,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` + ByteMapping map[bool][]byte `protobuf:"bytes,3,rep,name=byte_mapping" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (m *MessageWithMap) Reset() { *m = MessageWithMap{} } +func (*MessageWithMap) ProtoMessage() {} + +type FloatingPoint struct { + F float64 `protobuf:"fixed64,1,opt,name=f,proto3" json:"f,omitempty"` +} + +func (m *FloatingPoint) Reset() { *m = FloatingPoint{} } +func (*FloatingPoint) ProtoMessage() {} + +func init() { + proto.RegisterEnum("theproto3.MapEnum", MapEnum_name, MapEnum_value) + proto.RegisterEnum("theproto3.Message_Humour", Message_Humour_name, Message_Humour_value) +} +func (this *Message) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *Nested) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *AllMaps) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *MessageWithMap) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *FloatingPoint) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func Theproto3Description() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/test/combos/both/thetest.proto"), + Package: func(v string) *string { return &v }("test"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NinRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NidOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }, {Name: func(v string) *string { return &v }("NidNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidRepStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStruct"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinRepStruct"), + }}, + }, {Name: func(v string) *string { return &v }("NidOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomDash"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x64, 0x61, 0x73, 0x68, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NidRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinOptStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinNestedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNativeUnion"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStructUnion"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStructUnion"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Tree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Or"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.OrBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Leaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("OrBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Leaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("StrValue"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepTree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.ADeepBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndDeepBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepLeaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("ADeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndDeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepLeaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Tree"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Nil")}, {Name: func(v string) *string { return &v }("NidOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NidRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + DefaultValue: func(v string) *string { return &v }("C"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + DefaultValue: func(v string) *string { return &v }("E"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Timer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Time1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Time2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Data"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("MyExtendable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("OtherExtenable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("M"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(14), + End: func(v int32) *int32 { return &v }(17), + }, {Start: func(v int32) *int32 { return &v }(10), + End: func(v int32) *int32 { return &v }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("NestedDefinition"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("EnumField"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("NM"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedMessage"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedField1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedMsg"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedField1"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("NestedEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_NESTED"), + Number: func(v int32) *int32 { return &v }(1), + }}, + }}, + }, {Name: func(v string) *string { return &v }("NestedScope"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("true"), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("CustomContainer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("CustomStruct"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptCustom"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x5, 0x46, 0x69, 0x65, 0x6c, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameCustomType"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Ids"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Values"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("CustomNameEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + }, {Name: func(v string) *string { return &v }("NoExtensionsMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0}), 64025: proto.NewExtension([]byte{0xc8, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Unrecognized"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithInner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithInner.Inner"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Inner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithEmbed"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithEmbed.Embedded"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Embedded"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("TheTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }, {Name: func(v string) *string { return &v }("AnotherTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("D"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("E"), + Number: func(v int32) *int32 { return &v }(11), + }}, + Options: &google_protobuf.EnumOptions{XXX_extensions: map[int32]proto.Extension{62001: proto.NewExtension([]byte{0x88, 0xa3, 0x1e, 0x0})}}, + }}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("FieldA"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldB"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldC"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldA1"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldB1"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldC1"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }, {Name: func(v string) *string { return &v }("combos/unsafeboth/theproto3.proto"), + Package: func(v string) *string { return &v }("theproto3"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto", "github.com/gogo/protobuf/test/combos/both/thetest.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Message"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("hilarity"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".theproto3.Message.Humour"), + }, {Name: func(v string) *string { return &v }("height_in_cm"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("data"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("result_count"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("true_scotsman"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("score"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("nested"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Nested"), + }, {Name: func(v string) *string { return &v }("terrain"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Message.TerrainEntry"), + }, {Name: func(v string) *string { return &v }("proto2_field"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("proto2_value"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Message.Proto2ValueEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("TerrainEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Nested"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Proto2ValueEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Humour"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("UNKNOWN"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("PUNS"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("SLAPSTICK"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("BILL_BAILEY"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("Nested"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("bunny"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("AllMaps"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMap"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToDoubleMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToFloatMap"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToFloatMapEntry"), + }, {Name: func(v string) *string { return &v }("Int32Map"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Int32MapEntry"), + }, {Name: func(v string) *string { return &v }("Int64Map"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Int64MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint32Map"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Uint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint64Map"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Uint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint32Map"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint64Map"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed32Map"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Fixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed32Map"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sfixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed64Map"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Fixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed64Map"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sfixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("BoolMap"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.BoolMapEntry"), + }, {Name: func(v string) *string { return &v }("StringMap"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToBytesMap"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToBytesMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToEnumMap"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToEnumMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToMsgMap"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToMsgMapEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToFloatMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("BoolMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToBytesMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToEnumMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".theproto3.MapEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToMsgMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("MessageWithMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_mapping"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.NameMappingEntry"), + }, {Name: func(v string) *string { return &v }("msg_mapping"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.MsgMappingEntry"), + }, {Name: func(v string) *string { return &v }("byte_mapping"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.ByteMappingEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NameMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("MsgMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("ByteMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("FloatingPoint"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("f"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("MapEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("MA"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("MB"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("MC"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x1}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x1})}}, + Syntax: func(v string) *string { return &v }("proto3"), + }}, + } +} +func (x MapEnum) String() string { + s, ok := MapEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x Message_Humour) String() string { + s, ok := Message_Humour_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *Message) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Message) + if !ok { + return fmt.Errorf("that is not of type *Message") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Message but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Messagebut is not nil && this == nil") + } + if this.Name != that1.Name { + return fmt.Errorf("Name this(%v) Not Equal that(%v)", this.Name, that1.Name) + } + if this.Hilarity != that1.Hilarity { + return fmt.Errorf("Hilarity this(%v) Not Equal that(%v)", this.Hilarity, that1.Hilarity) + } + if this.HeightInCm != that1.HeightInCm { + return fmt.Errorf("HeightInCm this(%v) Not Equal that(%v)", this.HeightInCm, that1.HeightInCm) + } + if !bytes.Equal(this.Data, that1.Data) { + return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data) + } + if this.ResultCount != that1.ResultCount { + return fmt.Errorf("ResultCount this(%v) Not Equal that(%v)", this.ResultCount, that1.ResultCount) + } + if this.TrueScotsman != that1.TrueScotsman { + return fmt.Errorf("TrueScotsman this(%v) Not Equal that(%v)", this.TrueScotsman, that1.TrueScotsman) + } + if this.Score != that1.Score { + return fmt.Errorf("Score this(%v) Not Equal that(%v)", this.Score, that1.Score) + } + if len(this.Key) != len(that1.Key) { + return fmt.Errorf("Key this(%v) Not Equal that(%v)", len(this.Key), len(that1.Key)) + } + for i := range this.Key { + if this.Key[i] != that1.Key[i] { + return fmt.Errorf("Key this[%v](%v) Not Equal that[%v](%v)", i, this.Key[i], i, that1.Key[i]) + } + } + if !this.Nested.Equal(that1.Nested) { + return fmt.Errorf("Nested this(%v) Not Equal that(%v)", this.Nested, that1.Nested) + } + if len(this.Terrain) != len(that1.Terrain) { + return fmt.Errorf("Terrain this(%v) Not Equal that(%v)", len(this.Terrain), len(that1.Terrain)) + } + for i := range this.Terrain { + if !this.Terrain[i].Equal(that1.Terrain[i]) { + return fmt.Errorf("Terrain this[%v](%v) Not Equal that[%v](%v)", i, this.Terrain[i], i, that1.Terrain[i]) + } + } + if !this.Proto2Field.Equal(that1.Proto2Field) { + return fmt.Errorf("Proto2Field this(%v) Not Equal that(%v)", this.Proto2Field, that1.Proto2Field) + } + if len(this.Proto2Value) != len(that1.Proto2Value) { + return fmt.Errorf("Proto2Value this(%v) Not Equal that(%v)", len(this.Proto2Value), len(that1.Proto2Value)) + } + for i := range this.Proto2Value { + if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) { + return fmt.Errorf("Proto2Value this[%v](%v) Not Equal that[%v](%v)", i, this.Proto2Value[i], i, that1.Proto2Value[i]) + } + } + return nil +} +func (this *Message) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Message) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Name != that1.Name { + return false + } + if this.Hilarity != that1.Hilarity { + return false + } + if this.HeightInCm != that1.HeightInCm { + return false + } + if !bytes.Equal(this.Data, that1.Data) { + return false + } + if this.ResultCount != that1.ResultCount { + return false + } + if this.TrueScotsman != that1.TrueScotsman { + return false + } + if this.Score != that1.Score { + return false + } + if len(this.Key) != len(that1.Key) { + return false + } + for i := range this.Key { + if this.Key[i] != that1.Key[i] { + return false + } + } + if !this.Nested.Equal(that1.Nested) { + return false + } + if len(this.Terrain) != len(that1.Terrain) { + return false + } + for i := range this.Terrain { + if !this.Terrain[i].Equal(that1.Terrain[i]) { + return false + } + } + if !this.Proto2Field.Equal(that1.Proto2Field) { + return false + } + if len(this.Proto2Value) != len(that1.Proto2Value) { + return false + } + for i := range this.Proto2Value { + if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) { + return false + } + } + return true +} +func (this *Nested) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Nested) + if !ok { + return fmt.Errorf("that is not of type *Nested") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Nested but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Nestedbut is not nil && this == nil") + } + if this.Bunny != that1.Bunny { + return fmt.Errorf("Bunny this(%v) Not Equal that(%v)", this.Bunny, that1.Bunny) + } + return nil +} +func (this *Nested) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Nested) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Bunny != that1.Bunny { + return false + } + return true +} +func (this *AllMaps) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllMaps) + if !ok { + return fmt.Errorf("that is not of type *AllMaps") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllMaps but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllMapsbut is not nil && this == nil") + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap)) + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i]) + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap)) + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i]) + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map)) + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i]) + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map)) + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i]) + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map)) + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i]) + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map)) + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i]) + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map)) + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i]) + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map)) + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i]) + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map)) + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i]) + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map)) + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i]) + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map)) + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i]) + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map)) + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i]) + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap)) + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i]) + } + } + if len(this.StringMap) != len(that1.StringMap) { + return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap)) + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i]) + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap)) + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i]) + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap)) + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i]) + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap)) + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i]) + } + } + return nil +} +func (this *AllMaps) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllMaps) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return false + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return false + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return false + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return false + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return false + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return false + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return false + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return false + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return false + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return false + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return false + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return false + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return false + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return false + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return false + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return false + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return false + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return false + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return false + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return false + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return false + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return false + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return false + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return false + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return false + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return false + } + } + if len(this.StringMap) != len(that1.StringMap) { + return false + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return false + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return false + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return false + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return false + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return false + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return false + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return false + } + } + return true +} +func (this *MessageWithMap) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*MessageWithMap) + if !ok { + return fmt.Errorf("that is not of type *MessageWithMap") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *MessageWithMap but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *MessageWithMapbut is not nil && this == nil") + } + if len(this.NameMapping) != len(that1.NameMapping) { + return fmt.Errorf("NameMapping this(%v) Not Equal that(%v)", len(this.NameMapping), len(that1.NameMapping)) + } + for i := range this.NameMapping { + if this.NameMapping[i] != that1.NameMapping[i] { + return fmt.Errorf("NameMapping this[%v](%v) Not Equal that[%v](%v)", i, this.NameMapping[i], i, that1.NameMapping[i]) + } + } + if len(this.MsgMapping) != len(that1.MsgMapping) { + return fmt.Errorf("MsgMapping this(%v) Not Equal that(%v)", len(this.MsgMapping), len(that1.MsgMapping)) + } + for i := range this.MsgMapping { + if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) { + return fmt.Errorf("MsgMapping this[%v](%v) Not Equal that[%v](%v)", i, this.MsgMapping[i], i, that1.MsgMapping[i]) + } + } + if len(this.ByteMapping) != len(that1.ByteMapping) { + return fmt.Errorf("ByteMapping this(%v) Not Equal that(%v)", len(this.ByteMapping), len(that1.ByteMapping)) + } + for i := range this.ByteMapping { + if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) { + return fmt.Errorf("ByteMapping this[%v](%v) Not Equal that[%v](%v)", i, this.ByteMapping[i], i, that1.ByteMapping[i]) + } + } + return nil +} +func (this *MessageWithMap) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*MessageWithMap) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.NameMapping) != len(that1.NameMapping) { + return false + } + for i := range this.NameMapping { + if this.NameMapping[i] != that1.NameMapping[i] { + return false + } + } + if len(this.MsgMapping) != len(that1.MsgMapping) { + return false + } + for i := range this.MsgMapping { + if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) { + return false + } + } + if len(this.ByteMapping) != len(that1.ByteMapping) { + return false + } + for i := range this.ByteMapping { + if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) { + return false + } + } + return true +} +func (this *FloatingPoint) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return fmt.Errorf("that is not of type *FloatingPoint") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *FloatingPointbut is not nil && this == nil") + } + if this.F != that1.F { + return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F) + } + return nil +} +func (this *FloatingPoint) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.F != that1.F { + return false + } + return true +} + +type MessageFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetName() string + GetHilarity() Message_Humour + GetHeightInCm() uint32 + GetData() []byte + GetResultCount() int64 + GetTrueScotsman() bool + GetScore() float32 + GetKey() []uint64 + GetNested() *Nested + GetTerrain() map[int64]*Nested + GetProto2Field() *test.NinOptNative + GetProto2Value() map[int64]*test.NinOptEnum +} + +func (this *Message) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Message) TestProto() github_com_gogo_protobuf_proto.Message { + return NewMessageFromFace(this) +} + +func (this *Message) GetName() string { + return this.Name +} + +func (this *Message) GetHilarity() Message_Humour { + return this.Hilarity +} + +func (this *Message) GetHeightInCm() uint32 { + return this.HeightInCm +} + +func (this *Message) GetData() []byte { + return this.Data +} + +func (this *Message) GetResultCount() int64 { + return this.ResultCount +} + +func (this *Message) GetTrueScotsman() bool { + return this.TrueScotsman +} + +func (this *Message) GetScore() float32 { + return this.Score +} + +func (this *Message) GetKey() []uint64 { + return this.Key +} + +func (this *Message) GetNested() *Nested { + return this.Nested +} + +func (this *Message) GetTerrain() map[int64]*Nested { + return this.Terrain +} + +func (this *Message) GetProto2Field() *test.NinOptNative { + return this.Proto2Field +} + +func (this *Message) GetProto2Value() map[int64]*test.NinOptEnum { + return this.Proto2Value +} + +func NewMessageFromFace(that MessageFace) *Message { + this := &Message{} + this.Name = that.GetName() + this.Hilarity = that.GetHilarity() + this.HeightInCm = that.GetHeightInCm() + this.Data = that.GetData() + this.ResultCount = that.GetResultCount() + this.TrueScotsman = that.GetTrueScotsman() + this.Score = that.GetScore() + this.Key = that.GetKey() + this.Nested = that.GetNested() + this.Terrain = that.GetTerrain() + this.Proto2Field = that.GetProto2Field() + this.Proto2Value = that.GetProto2Value() + return this +} + +type NestedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetBunny() string +} + +func (this *Nested) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Nested) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedFromFace(this) +} + +func (this *Nested) GetBunny() string { + return this.Bunny +} + +func NewNestedFromFace(that NestedFace) *Nested { + this := &Nested{} + this.Bunny = that.GetBunny() + return this +} + +type AllMapsFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetStringToDoubleMap() map[string]float64 + GetStringToFloatMap() map[string]float32 + GetInt32Map() map[int32]int32 + GetInt64Map() map[int64]int64 + GetUint32Map() map[uint32]uint32 + GetUint64Map() map[uint64]uint64 + GetSint32Map() map[int32]int32 + GetSint64Map() map[int64]int64 + GetFixed32Map() map[uint32]uint32 + GetSfixed32Map() map[int32]int32 + GetFixed64Map() map[uint64]uint64 + GetSfixed64Map() map[int64]int64 + GetBoolMap() map[bool]bool + GetStringMap() map[string]string + GetStringToBytesMap() map[string][]byte + GetStringToEnumMap() map[string]MapEnum + GetStringToMsgMap() map[string]*FloatingPoint +} + +func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAllMapsFromFace(this) +} + +func (this *AllMaps) GetStringToDoubleMap() map[string]float64 { + return this.StringToDoubleMap +} + +func (this *AllMaps) GetStringToFloatMap() map[string]float32 { + return this.StringToFloatMap +} + +func (this *AllMaps) GetInt32Map() map[int32]int32 { + return this.Int32Map +} + +func (this *AllMaps) GetInt64Map() map[int64]int64 { + return this.Int64Map +} + +func (this *AllMaps) GetUint32Map() map[uint32]uint32 { + return this.Uint32Map +} + +func (this *AllMaps) GetUint64Map() map[uint64]uint64 { + return this.Uint64Map +} + +func (this *AllMaps) GetSint32Map() map[int32]int32 { + return this.Sint32Map +} + +func (this *AllMaps) GetSint64Map() map[int64]int64 { + return this.Sint64Map +} + +func (this *AllMaps) GetFixed32Map() map[uint32]uint32 { + return this.Fixed32Map +} + +func (this *AllMaps) GetSfixed32Map() map[int32]int32 { + return this.Sfixed32Map +} + +func (this *AllMaps) GetFixed64Map() map[uint64]uint64 { + return this.Fixed64Map +} + +func (this *AllMaps) GetSfixed64Map() map[int64]int64 { + return this.Sfixed64Map +} + +func (this *AllMaps) GetBoolMap() map[bool]bool { + return this.BoolMap +} + +func (this *AllMaps) GetStringMap() map[string]string { + return this.StringMap +} + +func (this *AllMaps) GetStringToBytesMap() map[string][]byte { + return this.StringToBytesMap +} + +func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum { + return this.StringToEnumMap +} + +func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint { + return this.StringToMsgMap +} + +func NewAllMapsFromFace(that AllMapsFace) *AllMaps { + this := &AllMaps{} + this.StringToDoubleMap = that.GetStringToDoubleMap() + this.StringToFloatMap = that.GetStringToFloatMap() + this.Int32Map = that.GetInt32Map() + this.Int64Map = that.GetInt64Map() + this.Uint32Map = that.GetUint32Map() + this.Uint64Map = that.GetUint64Map() + this.Sint32Map = that.GetSint32Map() + this.Sint64Map = that.GetSint64Map() + this.Fixed32Map = that.GetFixed32Map() + this.Sfixed32Map = that.GetSfixed32Map() + this.Fixed64Map = that.GetFixed64Map() + this.Sfixed64Map = that.GetSfixed64Map() + this.BoolMap = that.GetBoolMap() + this.StringMap = that.GetStringMap() + this.StringToBytesMap = that.GetStringToBytesMap() + this.StringToEnumMap = that.GetStringToEnumMap() + this.StringToMsgMap = that.GetStringToMsgMap() + return this +} + +type MessageWithMapFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNameMapping() map[int32]string + GetMsgMapping() map[int64]*FloatingPoint + GetByteMapping() map[bool][]byte +} + +func (this *MessageWithMap) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *MessageWithMap) TestProto() github_com_gogo_protobuf_proto.Message { + return NewMessageWithMapFromFace(this) +} + +func (this *MessageWithMap) GetNameMapping() map[int32]string { + return this.NameMapping +} + +func (this *MessageWithMap) GetMsgMapping() map[int64]*FloatingPoint { + return this.MsgMapping +} + +func (this *MessageWithMap) GetByteMapping() map[bool][]byte { + return this.ByteMapping +} + +func NewMessageWithMapFromFace(that MessageWithMapFace) *MessageWithMap { + this := &MessageWithMap{} + this.NameMapping = that.GetNameMapping() + this.MsgMapping = that.GetMsgMapping() + this.ByteMapping = that.GetByteMapping() + return this +} + +type FloatingPointFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetF() float64 +} + +func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message { + return NewFloatingPointFromFace(this) +} + +func (this *FloatingPoint) GetF() float64 { + return this.F +} + +func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint { + this := &FloatingPoint{} + this.F = that.GetF() + return this +} + +func (this *Message) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 16) + s = append(s, "&theproto3.Message{") + s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n") + s = append(s, "Hilarity: "+fmt.Sprintf("%#v", this.Hilarity)+",\n") + s = append(s, "HeightInCm: "+fmt.Sprintf("%#v", this.HeightInCm)+",\n") + s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") + s = append(s, "ResultCount: "+fmt.Sprintf("%#v", this.ResultCount)+",\n") + s = append(s, "TrueScotsman: "+fmt.Sprintf("%#v", this.TrueScotsman)+",\n") + s = append(s, "Score: "+fmt.Sprintf("%#v", this.Score)+",\n") + s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n") + if this.Nested != nil { + s = append(s, "Nested: "+fmt.Sprintf("%#v", this.Nested)+",\n") + } + keysForTerrain := make([]int64, 0, len(this.Terrain)) + for k := range this.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + mapStringForTerrain := "map[int64]*Nested{" + for _, k := range keysForTerrain { + mapStringForTerrain += fmt.Sprintf("%#v: %#v,", k, this.Terrain[k]) + } + mapStringForTerrain += "}" + if this.Terrain != nil { + s = append(s, "Terrain: "+mapStringForTerrain+",\n") + } + if this.Proto2Field != nil { + s = append(s, "Proto2Field: "+fmt.Sprintf("%#v", this.Proto2Field)+",\n") + } + keysForProto2Value := make([]int64, 0, len(this.Proto2Value)) + for k := range this.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + mapStringForProto2Value := "map[int64]*test.NinOptEnum{" + for _, k := range keysForProto2Value { + mapStringForProto2Value += fmt.Sprintf("%#v: %#v,", k, this.Proto2Value[k]) + } + mapStringForProto2Value += "}" + if this.Proto2Value != nil { + s = append(s, "Proto2Value: "+mapStringForProto2Value+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Nested) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&theproto3.Nested{") + s = append(s, "Bunny: "+fmt.Sprintf("%#v", this.Bunny)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllMaps) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 21) + s = append(s, "&theproto3.AllMaps{") + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + if this.StringToDoubleMap != nil { + s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n") + } + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + if this.StringToFloatMap != nil { + s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n") + } + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + if this.Int32Map != nil { + s = append(s, "Int32Map: "+mapStringForInt32Map+",\n") + } + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + if this.Int64Map != nil { + s = append(s, "Int64Map: "+mapStringForInt64Map+",\n") + } + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + if this.Uint32Map != nil { + s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n") + } + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + if this.Uint64Map != nil { + s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n") + } + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + if this.Sint32Map != nil { + s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n") + } + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + if this.Sint64Map != nil { + s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n") + } + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + if this.Fixed32Map != nil { + s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n") + } + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + if this.Sfixed32Map != nil { + s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n") + } + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + if this.Fixed64Map != nil { + s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n") + } + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + if this.Sfixed64Map != nil { + s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n") + } + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + if this.BoolMap != nil { + s = append(s, "BoolMap: "+mapStringForBoolMap+",\n") + } + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + if this.StringMap != nil { + s = append(s, "StringMap: "+mapStringForStringMap+",\n") + } + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + if this.StringToBytesMap != nil { + s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n") + } + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + if this.StringToEnumMap != nil { + s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n") + } + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + if this.StringToMsgMap != nil { + s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MessageWithMap) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&theproto3.MessageWithMap{") + keysForNameMapping := make([]int32, 0, len(this.NameMapping)) + for k := range this.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + mapStringForNameMapping := "map[int32]string{" + for _, k := range keysForNameMapping { + mapStringForNameMapping += fmt.Sprintf("%#v: %#v,", k, this.NameMapping[k]) + } + mapStringForNameMapping += "}" + if this.NameMapping != nil { + s = append(s, "NameMapping: "+mapStringForNameMapping+",\n") + } + keysForMsgMapping := make([]int64, 0, len(this.MsgMapping)) + for k := range this.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + mapStringForMsgMapping := "map[int64]*FloatingPoint{" + for _, k := range keysForMsgMapping { + mapStringForMsgMapping += fmt.Sprintf("%#v: %#v,", k, this.MsgMapping[k]) + } + mapStringForMsgMapping += "}" + if this.MsgMapping != nil { + s = append(s, "MsgMapping: "+mapStringForMsgMapping+",\n") + } + keysForByteMapping := make([]bool, 0, len(this.ByteMapping)) + for k := range this.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + mapStringForByteMapping := "map[bool][]byte{" + for _, k := range keysForByteMapping { + mapStringForByteMapping += fmt.Sprintf("%#v: %#v,", k, this.ByteMapping[k]) + } + mapStringForByteMapping += "}" + if this.ByteMapping != nil { + s = append(s, "ByteMapping: "+mapStringForByteMapping+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FloatingPoint) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&theproto3.FloatingPoint{") + s = append(s, "F: "+fmt.Sprintf("%#v", this.F)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringTheproto3(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringTheproto3(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedMessage(r randyTheproto3, easy bool) *Message { + this := &Message{} + this.Name = randStringTheproto3(r) + this.Hilarity = Message_Humour([]int32{0, 1, 2, 3}[r.Intn(4)]) + this.HeightInCm = uint32(r.Uint32()) + v1 := r.Intn(100) + this.Data = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Data[i] = byte(r.Intn(256)) + } + this.ResultCount = int64(r.Int63()) + if r.Intn(2) == 0 { + this.ResultCount *= -1 + } + this.TrueScotsman = bool(bool(r.Intn(2) == 0)) + this.Score = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Score *= -1 + } + v2 := r.Intn(100) + this.Key = make([]uint64, v2) + for i := 0; i < v2; i++ { + this.Key[i] = uint64(uint64(r.Uint32())) + } + if r.Intn(10) != 0 { + this.Nested = NewPopulatedNested(r, easy) + } + if r.Intn(10) != 0 { + v3 := r.Intn(10) + this.Terrain = make(map[int64]*Nested) + for i := 0; i < v3; i++ { + this.Terrain[int64(r.Int63())] = NewPopulatedNested(r, easy) + } + } + if r.Intn(10) != 0 { + this.Proto2Field = test.NewPopulatedNinOptNative(r, easy) + } + if r.Intn(10) != 0 { + v4 := r.Intn(10) + this.Proto2Value = make(map[int64]*test.NinOptEnum) + for i := 0; i < v4; i++ { + this.Proto2Value[int64(r.Int63())] = test.NewPopulatedNinOptEnum(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedNested(r randyTheproto3, easy bool) *Nested { + this := &Nested{} + this.Bunny = randStringTheproto3(r) + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedAllMaps(r randyTheproto3, easy bool) *AllMaps { + this := &AllMaps{} + if r.Intn(10) != 0 { + v5 := r.Intn(10) + this.StringToDoubleMap = make(map[string]float64) + for i := 0; i < v5; i++ { + v6 := randStringTheproto3(r) + this.StringToDoubleMap[v6] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.StringToDoubleMap[v6] *= -1 + } + } + } + if r.Intn(10) != 0 { + v7 := r.Intn(10) + this.StringToFloatMap = make(map[string]float32) + for i := 0; i < v7; i++ { + v8 := randStringTheproto3(r) + this.StringToFloatMap[v8] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.StringToFloatMap[v8] *= -1 + } + } + } + if r.Intn(10) != 0 { + v9 := r.Intn(10) + this.Int32Map = make(map[int32]int32) + for i := 0; i < v9; i++ { + v10 := int32(r.Int31()) + this.Int32Map[v10] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Int32Map[v10] *= -1 + } + } + } + if r.Intn(10) != 0 { + v11 := r.Intn(10) + this.Int64Map = make(map[int64]int64) + for i := 0; i < v11; i++ { + v12 := int64(r.Int63()) + this.Int64Map[v12] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Int64Map[v12] *= -1 + } + } + } + if r.Intn(10) != 0 { + v13 := r.Intn(10) + this.Uint32Map = make(map[uint32]uint32) + for i := 0; i < v13; i++ { + v14 := uint32(r.Uint32()) + this.Uint32Map[v14] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v15 := r.Intn(10) + this.Uint64Map = make(map[uint64]uint64) + for i := 0; i < v15; i++ { + v16 := uint64(uint64(r.Uint32())) + this.Uint64Map[v16] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v17 := r.Intn(10) + this.Sint32Map = make(map[int32]int32) + for i := 0; i < v17; i++ { + v18 := int32(r.Int31()) + this.Sint32Map[v18] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sint32Map[v18] *= -1 + } + } + } + if r.Intn(10) != 0 { + v19 := r.Intn(10) + this.Sint64Map = make(map[int64]int64) + for i := 0; i < v19; i++ { + v20 := int64(r.Int63()) + this.Sint64Map[v20] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sint64Map[v20] *= -1 + } + } + } + if r.Intn(10) != 0 { + v21 := r.Intn(10) + this.Fixed32Map = make(map[uint32]uint32) + for i := 0; i < v21; i++ { + v22 := uint32(r.Uint32()) + this.Fixed32Map[v22] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v23 := r.Intn(10) + this.Sfixed32Map = make(map[int32]int32) + for i := 0; i < v23; i++ { + v24 := int32(r.Int31()) + this.Sfixed32Map[v24] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sfixed32Map[v24] *= -1 + } + } + } + if r.Intn(10) != 0 { + v25 := r.Intn(10) + this.Fixed64Map = make(map[uint64]uint64) + for i := 0; i < v25; i++ { + v26 := uint64(uint64(r.Uint32())) + this.Fixed64Map[v26] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v27 := r.Intn(10) + this.Sfixed64Map = make(map[int64]int64) + for i := 0; i < v27; i++ { + v28 := int64(r.Int63()) + this.Sfixed64Map[v28] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sfixed64Map[v28] *= -1 + } + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(10) + this.BoolMap = make(map[bool]bool) + for i := 0; i < v29; i++ { + v30 := bool(bool(r.Intn(2) == 0)) + this.BoolMap[v30] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v31 := r.Intn(10) + this.StringMap = make(map[string]string) + for i := 0; i < v31; i++ { + this.StringMap[randStringTheproto3(r)] = randStringTheproto3(r) + } + } + if r.Intn(10) != 0 { + v32 := r.Intn(10) + this.StringToBytesMap = make(map[string][]byte) + for i := 0; i < v32; i++ { + v33 := r.Intn(100) + v34 := randStringTheproto3(r) + this.StringToBytesMap[v34] = make([]byte, v33) + for i := 0; i < v33; i++ { + this.StringToBytesMap[v34][i] = byte(r.Intn(256)) + } + } + } + if r.Intn(10) != 0 { + v35 := r.Intn(10) + this.StringToEnumMap = make(map[string]MapEnum) + for i := 0; i < v35; i++ { + this.StringToEnumMap[randStringTheproto3(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if r.Intn(10) != 0 { + v36 := r.Intn(10) + this.StringToMsgMap = make(map[string]*FloatingPoint) + for i := 0; i < v36; i++ { + this.StringToMsgMap[randStringTheproto3(r)] = NewPopulatedFloatingPoint(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedMessageWithMap(r randyTheproto3, easy bool) *MessageWithMap { + this := &MessageWithMap{} + if r.Intn(10) != 0 { + v37 := r.Intn(10) + this.NameMapping = make(map[int32]string) + for i := 0; i < v37; i++ { + this.NameMapping[int32(r.Int31())] = randStringTheproto3(r) + } + } + if r.Intn(10) != 0 { + v38 := r.Intn(10) + this.MsgMapping = make(map[int64]*FloatingPoint) + for i := 0; i < v38; i++ { + this.MsgMapping[int64(r.Int63())] = NewPopulatedFloatingPoint(r, easy) + } + } + if r.Intn(10) != 0 { + v39 := r.Intn(10) + this.ByteMapping = make(map[bool][]byte) + for i := 0; i < v39; i++ { + v40 := r.Intn(100) + v41 := bool(bool(r.Intn(2) == 0)) + this.ByteMapping[v41] = make([]byte, v40) + for i := 0; i < v40; i++ { + this.ByteMapping[v41][i] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedFloatingPoint(r randyTheproto3, easy bool) *FloatingPoint { + this := &FloatingPoint{} + this.F = float64(r.Float64()) + if r.Intn(2) == 0 { + this.F *= -1 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +type randyTheproto3 interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneTheproto3(r randyTheproto3) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringTheproto3(r randyTheproto3) string { + v42 := r.Intn(100) + tmps := make([]rune, v42) + for i := 0; i < v42; i++ { + tmps[i] = randUTF8RuneTheproto3(r) + } + return string(tmps) +} +func randUnrecognizedTheproto3(r randyTheproto3, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldTheproto3(data, r, fieldNumber, wire) + } + return data +} +func randFieldTheproto3(data []byte, r randyTheproto3, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + v43 := r.Int63() + if r.Intn(2) == 0 { + v43 *= -1 + } + data = encodeVarintPopulateTheproto3(data, uint64(v43)) + case 1: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateTheproto3(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateTheproto3(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Message) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + if m.Hilarity != 0 { + n += 1 + sovTheproto3(uint64(m.Hilarity)) + } + if m.HeightInCm != 0 { + n += 1 + sovTheproto3(uint64(m.HeightInCm)) + } + if m.Data != nil { + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + } + if m.ResultCount != 0 { + n += 1 + sovTheproto3(uint64(m.ResultCount)) + } + if m.TrueScotsman { + n += 2 + } + if m.Score != 0 { + n += 5 + } + if len(m.Key) > 0 { + for _, e := range m.Key { + n += 1 + sovTheproto3(uint64(e)) + } + } + if m.Nested != nil { + l = m.Nested.Size() + n += 1 + l + sovTheproto3(uint64(l)) + } + if len(m.Terrain) > 0 { + for k, v := range m.Terrain { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if m.Proto2Field != nil { + l = m.Proto2Field.Size() + n += 1 + l + sovTheproto3(uint64(l)) + } + if len(m.Proto2Value) > 0 { + for k, v := range m.Proto2Value { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *Nested) Size() (n int) { + var l int + _ = l + l = len(m.Bunny) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + return n +} + +func (m *AllMaps) Size() (n int) { + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + for k, v := range m.StringToDoubleMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToFloatMap) > 0 { + for k, v := range m.StringToFloatMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Int32Map) > 0 { + for k, v := range m.Int32Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Int64Map) > 0 { + for k, v := range m.Int64Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Uint32Map) > 0 { + for k, v := range m.Uint32Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Uint64Map) > 0 { + for k, v := range m.Uint64Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sint32Map) > 0 { + for k, v := range m.Sint32Map { + _ = k + _ = v + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sint64Map) > 0 { + for k, v := range m.Sint64Map { + _ = k + _ = v + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Fixed32Map) > 0 { + for k, v := range m.Fixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sfixed32Map) > 0 { + for k, v := range m.Sfixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Fixed64Map) > 0 { + for k, v := range m.Fixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sfixed64Map) > 0 { + for k, v := range m.Sfixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.BoolMap) > 0 { + for k, v := range m.BoolMap { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + 1 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringMap) > 0 { + for k, v := range m.StringMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToBytesMap) > 0 { + for k, v := range m.StringToBytesMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToEnumMap) > 0 { + for k, v := range m.StringToEnumMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToMsgMap) > 0 { + for k, v := range m.StringToMsgMap { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *MessageWithMap) Size() (n int) { + var l int + _ = l + if len(m.NameMapping) > 0 { + for k, v := range m.NameMapping { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.MsgMapping) > 0 { + for k, v := range m.MsgMapping { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.ByteMapping) > 0 { + for k, v := range m.ByteMapping { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *FloatingPoint) Size() (n int) { + var l int + _ = l + if m.F != 0 { + n += 9 + } + return n +} + +func sovTheproto3(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozTheproto3(x uint64) (n int) { + return sovTheproto3(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Message) String() string { + if this == nil { + return "nil" + } + keysForTerrain := make([]int64, 0, len(this.Terrain)) + for k := range this.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + mapStringForTerrain := "map[int64]*Nested{" + for _, k := range keysForTerrain { + mapStringForTerrain += fmt.Sprintf("%v: %v,", k, this.Terrain[k]) + } + mapStringForTerrain += "}" + keysForProto2Value := make([]int64, 0, len(this.Proto2Value)) + for k := range this.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + mapStringForProto2Value := "map[int64]*test.NinOptEnum{" + for _, k := range keysForProto2Value { + mapStringForProto2Value += fmt.Sprintf("%v: %v,", k, this.Proto2Value[k]) + } + mapStringForProto2Value += "}" + s := strings.Join([]string{`&Message{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Hilarity:` + fmt.Sprintf("%v", this.Hilarity) + `,`, + `HeightInCm:` + fmt.Sprintf("%v", this.HeightInCm) + `,`, + `Data:` + fmt.Sprintf("%v", this.Data) + `,`, + `ResultCount:` + fmt.Sprintf("%v", this.ResultCount) + `,`, + `TrueScotsman:` + fmt.Sprintf("%v", this.TrueScotsman) + `,`, + `Score:` + fmt.Sprintf("%v", this.Score) + `,`, + `Key:` + fmt.Sprintf("%v", this.Key) + `,`, + `Nested:` + strings.Replace(fmt.Sprintf("%v", this.Nested), "Nested", "Nested", 1) + `,`, + `Terrain:` + mapStringForTerrain + `,`, + `Proto2Field:` + strings.Replace(fmt.Sprintf("%v", this.Proto2Field), "NinOptNative", "test.NinOptNative", 1) + `,`, + `Proto2Value:` + mapStringForProto2Value + `,`, + `}`, + }, "") + return s +} +func (this *Nested) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Nested{`, + `Bunny:` + fmt.Sprintf("%v", this.Bunny) + `,`, + `}`, + }, "") + return s +} +func (this *AllMaps) String() string { + if this == nil { + return "nil" + } + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + s := strings.Join([]string{`&AllMaps{`, + `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`, + `StringToFloatMap:` + mapStringForStringToFloatMap + `,`, + `Int32Map:` + mapStringForInt32Map + `,`, + `Int64Map:` + mapStringForInt64Map + `,`, + `Uint32Map:` + mapStringForUint32Map + `,`, + `Uint64Map:` + mapStringForUint64Map + `,`, + `Sint32Map:` + mapStringForSint32Map + `,`, + `Sint64Map:` + mapStringForSint64Map + `,`, + `Fixed32Map:` + mapStringForFixed32Map + `,`, + `Sfixed32Map:` + mapStringForSfixed32Map + `,`, + `Fixed64Map:` + mapStringForFixed64Map + `,`, + `Sfixed64Map:` + mapStringForSfixed64Map + `,`, + `BoolMap:` + mapStringForBoolMap + `,`, + `StringMap:` + mapStringForStringMap + `,`, + `StringToBytesMap:` + mapStringForStringToBytesMap + `,`, + `StringToEnumMap:` + mapStringForStringToEnumMap + `,`, + `StringToMsgMap:` + mapStringForStringToMsgMap + `,`, + `}`, + }, "") + return s +} +func (this *MessageWithMap) String() string { + if this == nil { + return "nil" + } + keysForNameMapping := make([]int32, 0, len(this.NameMapping)) + for k := range this.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + mapStringForNameMapping := "map[int32]string{" + for _, k := range keysForNameMapping { + mapStringForNameMapping += fmt.Sprintf("%v: %v,", k, this.NameMapping[k]) + } + mapStringForNameMapping += "}" + keysForMsgMapping := make([]int64, 0, len(this.MsgMapping)) + for k := range this.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + mapStringForMsgMapping := "map[int64]*FloatingPoint{" + for _, k := range keysForMsgMapping { + mapStringForMsgMapping += fmt.Sprintf("%v: %v,", k, this.MsgMapping[k]) + } + mapStringForMsgMapping += "}" + keysForByteMapping := make([]bool, 0, len(this.ByteMapping)) + for k := range this.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + mapStringForByteMapping := "map[bool][]byte{" + for _, k := range keysForByteMapping { + mapStringForByteMapping += fmt.Sprintf("%v: %v,", k, this.ByteMapping[k]) + } + mapStringForByteMapping += "}" + s := strings.Join([]string{`&MessageWithMap{`, + `NameMapping:` + mapStringForNameMapping + `,`, + `MsgMapping:` + mapStringForMsgMapping + `,`, + `ByteMapping:` + mapStringForByteMapping + `,`, + `}`, + }, "") + return s +} +func (this *FloatingPoint) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FloatingPoint{`, + `F:` + fmt.Sprintf("%v", this.F) + `,`, + `}`, + }, "") + return s +} +func valueToStringTheproto3(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Message) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Message) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(m.Name))) + i += copy(data[i:], m.Name) + } + if m.Hilarity != 0 { + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(m.Hilarity)) + } + if m.HeightInCm != 0 { + data[i] = 0x18 + i++ + i = encodeVarintTheproto3(data, i, uint64(m.HeightInCm)) + } + if m.Data != nil { + if len(m.Data) > 0 { + data[i] = 0x22 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(m.Data))) + i += copy(data[i:], m.Data) + } + } + if len(m.Key) > 0 { + for _, num := range m.Key { + data[i] = 0x28 + i++ + i = encodeVarintTheproto3(data, i, uint64(num)) + } + } + if m.Nested != nil { + data[i] = 0x32 + i++ + i = encodeVarintTheproto3(data, i, uint64(m.Nested.Size())) + n1, err := m.Nested.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n1 + } + if m.ResultCount != 0 { + data[i] = 0x38 + i++ + i = encodeVarintTheproto3(data, i, uint64(m.ResultCount)) + } + if m.TrueScotsman { + data[i] = 0x40 + i++ + if m.TrueScotsman { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Score != 0 { + data[i] = 0x4d + i++ + *(*float32)(unsafe.Pointer(&data[i])) = m.Score + i += 4 + } + if len(m.Terrain) > 0 { + keysForTerrain := make([]int64, 0, len(m.Terrain)) + for k := range m.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + for _, k := range keysForTerrain { + data[i] = 0x52 + i++ + v := m.Terrain[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + msgSize + sovTheproto3(uint64(msgSize)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(v.Size())) + n2, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + } + } + if m.Proto2Field != nil { + data[i] = 0x5a + i++ + i = encodeVarintTheproto3(data, i, uint64(m.Proto2Field.Size())) + n3, err := m.Proto2Field.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n3 + } + if len(m.Proto2Value) > 0 { + keysForProto2Value := make([]int64, 0, len(m.Proto2Value)) + for k := range m.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + for _, k := range keysForProto2Value { + data[i] = 0x6a + i++ + v := m.Proto2Value[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + msgSize + sovTheproto3(uint64(msgSize)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(v.Size())) + n4, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n4 + } + } + return i, nil +} + +func (m *Nested) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Nested) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Bunny) > 0 { + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(m.Bunny))) + i += copy(data[i:], m.Bunny) + } + return i, nil +} + +func (m *AllMaps) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AllMaps) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + keysForStringToDoubleMap := make([]string, 0, len(m.StringToDoubleMap)) + for k := range m.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + for _, k := range keysForStringToDoubleMap { + data[i] = 0xa + i++ + v := m.StringToDoubleMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x11 + i++ + i = encodeFixed64Theproto3(data, i, uint64(math.Float64bits(v))) + } + } + if len(m.StringToFloatMap) > 0 { + keysForStringToFloatMap := make([]string, 0, len(m.StringToFloatMap)) + for k := range m.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + for _, k := range keysForStringToFloatMap { + data[i] = 0x12 + i++ + v := m.StringToFloatMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x15 + i++ + i = encodeFixed32Theproto3(data, i, uint32(math.Float32bits(v))) + } + } + if len(m.Int32Map) > 0 { + keysForInt32Map := make([]int32, 0, len(m.Int32Map)) + for k := range m.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + for _, k := range keysForInt32Map { + data[i] = 0x1a + i++ + v := m.Int32Map[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.Int64Map) > 0 { + keysForInt64Map := make([]int64, 0, len(m.Int64Map)) + for k := range m.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + for _, k := range keysForInt64Map { + data[i] = 0x22 + i++ + v := m.Int64Map[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.Uint32Map) > 0 { + keysForUint32Map := make([]uint32, 0, len(m.Uint32Map)) + for k := range m.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + for _, k := range keysForUint32Map { + data[i] = 0x2a + i++ + v := m.Uint32Map[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.Uint64Map) > 0 { + keysForUint64Map := make([]uint64, 0, len(m.Uint64Map)) + for k := range m.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + for _, k := range keysForUint64Map { + data[i] = 0x32 + i++ + v := m.Uint64Map[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.Sint32Map) > 0 { + keysForSint32Map := make([]int32, 0, len(m.Sint32Map)) + for k := range m.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + for _, k := range keysForSint32Map { + data[i] = 0x3a + i++ + v := m.Sint32Map[k] + mapSize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint32(k)<<1)^uint32((k>>31)))) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint32(v)<<1)^uint32((v>>31)))) + } + } + if len(m.Sint64Map) > 0 { + keysForSint64Map := make([]int64, 0, len(m.Sint64Map)) + for k := range m.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + for _, k := range keysForSint64Map { + data[i] = 0x42 + i++ + v := m.Sint64Map[k] + mapSize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint64(k)<<1)^uint64((k>>63)))) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint64(v)<<1)^uint64((v>>63)))) + } + } + if len(m.Fixed32Map) > 0 { + keysForFixed32Map := make([]uint32, 0, len(m.Fixed32Map)) + for k := range m.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + for _, k := range keysForFixed32Map { + data[i] = 0x4a + i++ + v := m.Fixed32Map[k] + mapSize := 1 + 4 + 1 + 4 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xd + i++ + i = encodeFixed32Theproto3(data, i, uint32(k)) + data[i] = 0x15 + i++ + i = encodeFixed32Theproto3(data, i, uint32(v)) + } + } + if len(m.Sfixed32Map) > 0 { + keysForSfixed32Map := make([]int32, 0, len(m.Sfixed32Map)) + for k := range m.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + for _, k := range keysForSfixed32Map { + data[i] = 0x52 + i++ + v := m.Sfixed32Map[k] + mapSize := 1 + 4 + 1 + 4 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xd + i++ + i = encodeFixed32Theproto3(data, i, uint32(k)) + data[i] = 0x15 + i++ + i = encodeFixed32Theproto3(data, i, uint32(v)) + } + } + if len(m.Fixed64Map) > 0 { + keysForFixed64Map := make([]uint64, 0, len(m.Fixed64Map)) + for k := range m.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + for _, k := range keysForFixed64Map { + data[i] = 0x5a + i++ + v := m.Fixed64Map[k] + mapSize := 1 + 8 + 1 + 8 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x9 + i++ + i = encodeFixed64Theproto3(data, i, uint64(k)) + data[i] = 0x11 + i++ + i = encodeFixed64Theproto3(data, i, uint64(v)) + } + } + if len(m.Sfixed64Map) > 0 { + keysForSfixed64Map := make([]int64, 0, len(m.Sfixed64Map)) + for k := range m.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + for _, k := range keysForSfixed64Map { + data[i] = 0x62 + i++ + v := m.Sfixed64Map[k] + mapSize := 1 + 8 + 1 + 8 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x9 + i++ + i = encodeFixed64Theproto3(data, i, uint64(k)) + data[i] = 0x11 + i++ + i = encodeFixed64Theproto3(data, i, uint64(v)) + } + } + if len(m.BoolMap) > 0 { + keysForBoolMap := make([]bool, 0, len(m.BoolMap)) + for k := range m.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + for _, k := range keysForBoolMap { + data[i] = 0x6a + i++ + v := m.BoolMap[k] + mapSize := 1 + 1 + 1 + 1 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + if k { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x10 + i++ + if v { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.StringMap) > 0 { + keysForStringMap := make([]string, 0, len(m.StringMap)) + for k := range m.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + for _, k := range keysForStringMap { + data[i] = 0x72 + i++ + v := m.StringMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.StringToBytesMap) > 0 { + keysForStringToBytesMap := make([]string, 0, len(m.StringToBytesMap)) + for k := range m.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + for _, k := range keysForStringToBytesMap { + data[i] = 0x7a + i++ + v := m.StringToBytesMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.StringToEnumMap) > 0 { + keysForStringToEnumMap := make([]string, 0, len(m.StringToEnumMap)) + for k := range m.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + for _, k := range keysForStringToEnumMap { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + v := m.StringToEnumMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.StringToMsgMap) > 0 { + keysForStringToMsgMap := make([]string, 0, len(m.StringToMsgMap)) + for k := range m.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + for _, k := range keysForStringToMsgMap { + data[i] = 0x8a + i++ + data[i] = 0x1 + i++ + v := m.StringToMsgMap[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + msgSize + sovTheproto3(uint64(msgSize)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(v.Size())) + n5, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n5 + } + } + return i, nil +} + +func (m *MessageWithMap) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *MessageWithMap) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.NameMapping) > 0 { + keysForNameMapping := make([]int32, 0, len(m.NameMapping)) + for k := range m.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + for _, k := range keysForNameMapping { + data[i] = 0xa + i++ + v := m.NameMapping[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + len(v) + sovTheproto3(uint64(len(v))) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.MsgMapping) > 0 { + keysForMsgMapping := make([]int64, 0, len(m.MsgMapping)) + for k := range m.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + for _, k := range keysForMsgMapping { + data[i] = 0x12 + i++ + v := m.MsgMapping[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + sozTheproto3(uint64(k)) + 1 + msgSize + sovTheproto3(uint64(msgSize)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint64(k)<<1)^uint64((k>>63)))) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(v.Size())) + n6, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n6 + } + } + if len(m.ByteMapping) > 0 { + keysForByteMapping := make([]bool, 0, len(m.ByteMapping)) + for k := range m.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + for _, k := range keysForByteMapping { + data[i] = 0x1a + i++ + v := m.ByteMapping[k] + mapSize := 1 + 1 + 1 + len(v) + sovTheproto3(uint64(len(v))) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + if k { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + return i, nil +} + +func (m *FloatingPoint) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *FloatingPoint) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.F != 0 { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = m.F + i += 8 + } + return i, nil +} + +func encodeFixed64Theproto3(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Theproto3(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintTheproto3(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *Message) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Message: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Message: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Hilarity", wireType) + } + m.Hilarity = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Hilarity |= (Message_Humour(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field HeightInCm", wireType) + } + m.HeightInCm = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.HeightInCm |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Key = append(m.Key, v) + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Nested", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Nested == nil { + m.Nested = &Nested{} + } + if err := m.Nested.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ResultCount", wireType) + } + m.ResultCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ResultCount |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TrueScotsman", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TrueScotsman = bool(v != 0) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Score", wireType) + } + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + m.Score = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Terrain", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &Nested{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.Terrain == nil { + m.Terrain = make(map[int64]*Nested) + } + m.Terrain[mapkey] = mapvalue + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proto2Field", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Proto2Field == nil { + m.Proto2Field = &test.NinOptNative{} + } + if err := m.Proto2Field.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proto2Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &test.NinOptEnum{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.Proto2Value == nil { + m.Proto2Value = make(map[int64]*test.NinOptEnum) + } + m.Proto2Value[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTheproto3Unsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Nested) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Nested: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Nested: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Bunny", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Bunny = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTheproto3Unsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AllMaps) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AllMaps: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AllMaps: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvaluetemp = uint64(data[iNdEx-8]) + mapvaluetemp |= uint64(data[iNdEx-7]) << 8 + mapvaluetemp |= uint64(data[iNdEx-6]) << 16 + mapvaluetemp |= uint64(data[iNdEx-5]) << 24 + mapvaluetemp |= uint64(data[iNdEx-4]) << 32 + mapvaluetemp |= uint64(data[iNdEx-3]) << 40 + mapvaluetemp |= uint64(data[iNdEx-2]) << 48 + mapvaluetemp |= uint64(data[iNdEx-1]) << 56 + mapvalue := math.Float64frombits(mapvaluetemp) + if m.StringToDoubleMap == nil { + m.StringToDoubleMap = make(map[string]float64) + } + m.StringToDoubleMap[mapkey] = mapvalue + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvaluetemp = uint32(data[iNdEx-4]) + mapvaluetemp |= uint32(data[iNdEx-3]) << 8 + mapvaluetemp |= uint32(data[iNdEx-2]) << 16 + mapvaluetemp |= uint32(data[iNdEx-1]) << 24 + mapvalue := math.Float32frombits(mapvaluetemp) + if m.StringToFloatMap == nil { + m.StringToFloatMap = make(map[string]float32) + } + m.StringToFloatMap[mapkey] = mapvalue + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Int32Map == nil { + m.Int32Map = make(map[int32]int32) + } + m.Int32Map[mapkey] = mapvalue + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Int64Map == nil { + m.Int64Map = make(map[int64]int64) + } + m.Int64Map[mapkey] = mapvalue + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Uint32Map == nil { + m.Uint32Map = make(map[uint32]uint32) + } + m.Uint32Map[mapkey] = mapvalue + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Uint64Map == nil { + m.Uint64Map = make(map[uint64]uint64) + } + m.Uint64Map[mapkey] = mapvalue + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31)) + mapkey := int32(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31)) + mapvalue := int32(mapvaluetemp) + if m.Sint32Map == nil { + m.Sint32Map = make(map[int32]int32) + } + m.Sint32Map[mapkey] = mapvalue + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63) + mapkey := int64(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63) + mapvalue := int64(mapvaluetemp) + if m.Sint64Map == nil { + m.Sint64Map = make(map[int64]int64) + } + m.Sint64Map[mapkey] = mapvalue + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapkey = uint32(data[iNdEx-4]) + mapkey |= uint32(data[iNdEx-3]) << 8 + mapkey |= uint32(data[iNdEx-2]) << 16 + mapkey |= uint32(data[iNdEx-1]) << 24 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvalue = uint32(data[iNdEx-4]) + mapvalue |= uint32(data[iNdEx-3]) << 8 + mapvalue |= uint32(data[iNdEx-2]) << 16 + mapvalue |= uint32(data[iNdEx-1]) << 24 + if m.Fixed32Map == nil { + m.Fixed32Map = make(map[uint32]uint32) + } + m.Fixed32Map[mapkey] = mapvalue + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapkey = int32(data[iNdEx-4]) + mapkey |= int32(data[iNdEx-3]) << 8 + mapkey |= int32(data[iNdEx-2]) << 16 + mapkey |= int32(data[iNdEx-1]) << 24 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvalue = int32(data[iNdEx-4]) + mapvalue |= int32(data[iNdEx-3]) << 8 + mapvalue |= int32(data[iNdEx-2]) << 16 + mapvalue |= int32(data[iNdEx-1]) << 24 + if m.Sfixed32Map == nil { + m.Sfixed32Map = make(map[int32]int32) + } + m.Sfixed32Map[mapkey] = mapvalue + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapkey = uint64(data[iNdEx-8]) + mapkey |= uint64(data[iNdEx-7]) << 8 + mapkey |= uint64(data[iNdEx-6]) << 16 + mapkey |= uint64(data[iNdEx-5]) << 24 + mapkey |= uint64(data[iNdEx-4]) << 32 + mapkey |= uint64(data[iNdEx-3]) << 40 + mapkey |= uint64(data[iNdEx-2]) << 48 + mapkey |= uint64(data[iNdEx-1]) << 56 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvalue = uint64(data[iNdEx-8]) + mapvalue |= uint64(data[iNdEx-7]) << 8 + mapvalue |= uint64(data[iNdEx-6]) << 16 + mapvalue |= uint64(data[iNdEx-5]) << 24 + mapvalue |= uint64(data[iNdEx-4]) << 32 + mapvalue |= uint64(data[iNdEx-3]) << 40 + mapvalue |= uint64(data[iNdEx-2]) << 48 + mapvalue |= uint64(data[iNdEx-1]) << 56 + if m.Fixed64Map == nil { + m.Fixed64Map = make(map[uint64]uint64) + } + m.Fixed64Map[mapkey] = mapvalue + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapkey = int64(data[iNdEx-8]) + mapkey |= int64(data[iNdEx-7]) << 8 + mapkey |= int64(data[iNdEx-6]) << 16 + mapkey |= int64(data[iNdEx-5]) << 24 + mapkey |= int64(data[iNdEx-4]) << 32 + mapkey |= int64(data[iNdEx-3]) << 40 + mapkey |= int64(data[iNdEx-2]) << 48 + mapkey |= int64(data[iNdEx-1]) << 56 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvalue = int64(data[iNdEx-8]) + mapvalue |= int64(data[iNdEx-7]) << 8 + mapvalue |= int64(data[iNdEx-6]) << 16 + mapvalue |= int64(data[iNdEx-5]) << 24 + mapvalue |= int64(data[iNdEx-4]) << 32 + mapvalue |= int64(data[iNdEx-3]) << 40 + mapvalue |= int64(data[iNdEx-2]) << 48 + mapvalue |= int64(data[iNdEx-1]) << 56 + if m.Sfixed64Map == nil { + m.Sfixed64Map = make(map[int64]int64) + } + m.Sfixed64Map[mapkey] = mapvalue + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkey := bool(mapkeytemp != 0) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvalue := bool(mapvaluetemp != 0) + if m.BoolMap == nil { + m.BoolMap = make(map[bool]bool) + } + m.BoolMap[mapkey] = mapvalue + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue := string(data[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + if m.StringMap == nil { + m.StringMap = make(map[string]string) + } + m.StringMap[mapkey] = mapvalue + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapbyteLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := make([]byte, mapbyteLen) + copy(mapvalue, data[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + if m.StringToBytesMap == nil { + m.StringToBytesMap = make(map[string][]byte) + } + m.StringToBytesMap[mapkey] = mapvalue + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue MapEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (MapEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.StringToEnumMap == nil { + m.StringToEnumMap = make(map[string]MapEnum) + } + m.StringToEnumMap[mapkey] = mapvalue + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &FloatingPoint{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.StringToMsgMap == nil { + m.StringToMsgMap = make(map[string]*FloatingPoint) + } + m.StringToMsgMap[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTheproto3Unsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MessageWithMap) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MessageWithMap: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MessageWithMap: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NameMapping", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue := string(data[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + if m.NameMapping == nil { + m.NameMapping = make(map[int32]string) + } + m.NameMapping[mapkey] = mapvalue + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MsgMapping", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63) + mapkey := int64(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &FloatingPoint{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.MsgMapping == nil { + m.MsgMapping = make(map[int64]*FloatingPoint) + } + m.MsgMapping[mapkey] = mapvalue + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ByteMapping", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkey := bool(mapkeytemp != 0) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapbyteLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := make([]byte, mapbyteLen) + copy(mapvalue, data[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + if m.ByteMapping == nil { + m.ByteMapping = make(map[bool][]byte) + } + m.ByteMapping[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTheproto3Unsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FloatingPoint) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FloatingPoint: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FloatingPoint: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field F", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.F = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + default: + iNdEx = preIndex + skippy, err := skipTheproto3Unsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTheproto3Unsafe(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthTheproto3Unsafe + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipTheproto3Unsafe(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthTheproto3Unsafe = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTheproto3Unsafe = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeboth/theproto3.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeboth/theproto3.proto new file mode 100644 index 0000000000000000000000000000000000000000..5f2886b6b7f02340598dd8e1b9ec944cc6246c98 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeboth/theproto3.proto @@ -0,0 +1,129 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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 theproto3; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +import "github.com/gogo/protobuf/test/combos/both/thetest.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = true; +option (gogoproto.unsafe_unmarshaler_all) = true; + +message Message { + enum Humour { + UNKNOWN = 0; + PUNS = 1; + SLAPSTICK = 2; + BILL_BAILEY = 3; + } + + string name = 1; + Humour hilarity = 2; + uint32 height_in_cm = 3; + bytes data = 4; + int64 result_count = 7; + bool true_scotsman = 8; + float score = 9; + + repeated uint64 key = 5; + Nested nested = 6; + + map terrain = 10; + test.NinOptNative proto2_field = 11; + map proto2_value = 13; +} + +message Nested { + string bunny = 1; +} + +enum MapEnum { + MA = 0; + MB = 1; + MC = 2; +} + +message AllMaps { + map StringToDoubleMap = 1; + map StringToFloatMap = 2; + map Int32Map = 3; + map Int64Map = 4; + map Uint32Map = 5; + map Uint64Map = 6; + map Sint32Map = 7; + map Sint64Map = 8; + map Fixed32Map = 9; + map Sfixed32Map = 10; + map Fixed64Map = 11; + map Sfixed64Map = 12; + map BoolMap = 13; + map StringMap = 14; + map StringToBytesMap = 15; + map StringToEnumMap = 16; + map StringToMsgMap = 17; +} + +message MessageWithMap { + map name_mapping = 1; + map msg_mapping = 2; + map byte_mapping = 3; +} + +message FloatingPoint { + double f = 1; +} \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeboth/theproto3pb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeboth/theproto3pb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..6bb3a2d779e1930ce9eb344818f8e8938cbd9549 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeboth/theproto3pb_test.go @@ -0,0 +1,1232 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeboth/theproto3.proto +// DO NOT EDIT! + +/* +Package theproto3 is a generated protocol buffer package. + +It is generated from these files: + combos/unsafeboth/theproto3.proto + +It has these top-level messages: + Message + Nested + AllMaps + MessageWithMap + FloatingPoint +*/ +package theproto3 + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" +// discarding unused import test "github.com/gogo/protobuf/test/combos/both" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestMessageProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestMessageMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkMessageProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Message, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMessageProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessage(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Message{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nested, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNested(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNested(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Nested{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAllMapsMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAllMapsProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMaps(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AllMaps{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageWithMapProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestMessageWithMapMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkMessageWithMapProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MessageWithMap, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMessageWithMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMessageWithMapProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessageWithMap(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &MessageWithMap{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestFloatingPointMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkFloatingPointProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedFloatingPoint(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &FloatingPoint{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllMapsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMessageWithMapJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestFloatingPointJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMessageProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Message{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Message{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageWithMapProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageWithMapProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTheproto3Description(t *testing.T) { + Theproto3Description() +} +func TestMessageVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllMapsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMessageWithMapVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestFloatingPointVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMessageFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAllMapsFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestMessageWithMapFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestFloatingPointFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestMessageGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllMapsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMessageWithMapGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestFloatingPointGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMessageSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMessageSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Message, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nested, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNested(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAllMapsSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageWithMapSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMessageWithMapSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MessageWithMap, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMessageWithMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkFloatingPointSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllMapsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestMessageWithMapStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestFloatingPointStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafemarshaler/nilmaps_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafemarshaler/nilmaps_test.go new file mode 100644 index 0000000000000000000000000000000000000000..1b05c72b2c453fe78cac35296c395d0dc5951bc8 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafemarshaler/nilmaps_test.go @@ -0,0 +1,39 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 theproto3 + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "testing" +) + +func TestNilMaps(t *testing.T) { + m := &AllMaps{StringToMsgMap: map[string]*FloatingPoint{"a": nil}} + if _, err := proto.Marshal(m); err == nil { + t.Fatalf("expected error") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafemarshaler/theproto3.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafemarshaler/theproto3.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..284b2f806a11b93a7fd71e489869d97db3b42f4b --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafemarshaler/theproto3.pb.go @@ -0,0 +1,8298 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafemarshaler/theproto3.proto +// DO NOT EDIT! + +/* + Package theproto3 is a generated protocol buffer package. + + It is generated from these files: + combos/unsafemarshaler/theproto3.proto + + It has these top-level messages: + Message + Nested + AllMaps + MessageWithMap + FloatingPoint +*/ +package theproto3 + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" +import test "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" +import github_com_gogo_protobuf_sortkeys "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/sortkeys" + +import unsafe "unsafe" +import errors "errors" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type MapEnum int32 + +const ( + MA MapEnum = 0 + MB MapEnum = 1 + MC MapEnum = 2 +) + +var MapEnum_name = map[int32]string{ + 0: "MA", + 1: "MB", + 2: "MC", +} +var MapEnum_value = map[string]int32{ + "MA": 0, + "MB": 1, + "MC": 2, +} + +type Message_Humour int32 + +const ( + UNKNOWN Message_Humour = 0 + PUNS Message_Humour = 1 + SLAPSTICK Message_Humour = 2 + BILL_BAILEY Message_Humour = 3 +) + +var Message_Humour_name = map[int32]string{ + 0: "UNKNOWN", + 1: "PUNS", + 2: "SLAPSTICK", + 3: "BILL_BAILEY", +} +var Message_Humour_value = map[string]int32{ + "UNKNOWN": 0, + "PUNS": 1, + "SLAPSTICK": 2, + "BILL_BAILEY": 3, +} + +type Message struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Hilarity Message_Humour `protobuf:"varint,2,opt,name=hilarity,proto3,enum=theproto3.Message_Humour" json:"hilarity,omitempty"` + HeightInCm uint32 `protobuf:"varint,3,opt,name=height_in_cm,proto3" json:"height_in_cm,omitempty"` + Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` + ResultCount int64 `protobuf:"varint,7,opt,name=result_count,proto3" json:"result_count,omitempty"` + TrueScotsman bool `protobuf:"varint,8,opt,name=true_scotsman,proto3" json:"true_scotsman,omitempty"` + Score float32 `protobuf:"fixed32,9,opt,name=score,proto3" json:"score,omitempty"` + Key []uint64 `protobuf:"varint,5,rep,name=key" json:"key,omitempty"` + Nested *Nested `protobuf:"bytes,6,opt,name=nested" json:"nested,omitempty"` + Terrain map[int64]*Nested `protobuf:"bytes,10,rep,name=terrain" json:"terrain,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` + Proto2Field *test.NinOptNative `protobuf:"bytes,11,opt,name=proto2_field" json:"proto2_field,omitempty"` + Proto2Value map[int64]*test.NinOptEnum `protobuf:"bytes,13,rep,name=proto2_value" json:"proto2_value,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` +} + +func (m *Message) Reset() { *m = Message{} } +func (*Message) ProtoMessage() {} + +type Nested struct { + Bunny string `protobuf:"bytes,1,opt,name=bunny,proto3" json:"bunny,omitempty"` +} + +func (m *Nested) Reset() { *m = Nested{} } +func (*Nested) ProtoMessage() {} + +type AllMaps struct { + StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key,proto3" protobuf_val:"zigzag32,2,opt,name=value,proto3"` + Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"` + Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=theproto3.MapEnum"` + StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` +} + +func (m *AllMaps) Reset() { *m = AllMaps{} } +func (*AllMaps) ProtoMessage() {} + +type MessageWithMap struct { + NameMapping map[int32]string `protobuf:"bytes,1,rep,name=name_mapping" json:"name_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + MsgMapping map[int64]*FloatingPoint `protobuf:"bytes,2,rep,name=msg_mapping" json:"msg_mapping,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` + ByteMapping map[bool][]byte `protobuf:"bytes,3,rep,name=byte_mapping" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (m *MessageWithMap) Reset() { *m = MessageWithMap{} } +func (*MessageWithMap) ProtoMessage() {} + +type FloatingPoint struct { + F float64 `protobuf:"fixed64,1,opt,name=f,proto3" json:"f,omitempty"` +} + +func (m *FloatingPoint) Reset() { *m = FloatingPoint{} } +func (*FloatingPoint) ProtoMessage() {} + +func init() { + proto.RegisterEnum("theproto3.MapEnum", MapEnum_name, MapEnum_value) + proto.RegisterEnum("theproto3.Message_Humour", Message_Humour_name, Message_Humour_value) +} +func (this *Message) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *Nested) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *AllMaps) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *MessageWithMap) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *FloatingPoint) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func Theproto3Description() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/test/combos/both/thetest.proto"), + Package: func(v string) *string { return &v }("test"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NinRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NidOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }, {Name: func(v string) *string { return &v }("NidNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidRepStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStruct"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinRepStruct"), + }}, + }, {Name: func(v string) *string { return &v }("NidOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomDash"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x64, 0x61, 0x73, 0x68, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NidRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinOptStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinNestedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNativeUnion"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStructUnion"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStructUnion"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Tree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Or"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.OrBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Leaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("OrBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Leaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("StrValue"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepTree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.ADeepBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndDeepBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepLeaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("ADeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndDeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepLeaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Tree"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Nil")}, {Name: func(v string) *string { return &v }("NidOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NidRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + DefaultValue: func(v string) *string { return &v }("C"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + DefaultValue: func(v string) *string { return &v }("E"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Timer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Time1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Time2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Data"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("MyExtendable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("OtherExtenable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("M"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(14), + End: func(v int32) *int32 { return &v }(17), + }, {Start: func(v int32) *int32 { return &v }(10), + End: func(v int32) *int32 { return &v }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("NestedDefinition"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("EnumField"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("NM"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedMessage"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedField1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedMsg"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedField1"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("NestedEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_NESTED"), + Number: func(v int32) *int32 { return &v }(1), + }}, + }}, + }, {Name: func(v string) *string { return &v }("NestedScope"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("true"), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("CustomContainer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("CustomStruct"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptCustom"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x5, 0x46, 0x69, 0x65, 0x6c, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameCustomType"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Ids"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Values"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("CustomNameEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + }, {Name: func(v string) *string { return &v }("NoExtensionsMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0}), 64025: proto.NewExtension([]byte{0xc8, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Unrecognized"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithInner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithInner.Inner"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Inner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithEmbed"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithEmbed.Embedded"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Embedded"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("TheTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }, {Name: func(v string) *string { return &v }("AnotherTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("D"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("E"), + Number: func(v int32) *int32 { return &v }(11), + }}, + Options: &google_protobuf.EnumOptions{XXX_extensions: map[int32]proto.Extension{62001: proto.NewExtension([]byte{0x88, 0xa3, 0x1e, 0x0})}}, + }}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("FieldA"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldB"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldC"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldA1"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldB1"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldC1"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }, {Name: func(v string) *string { return &v }("combos/unsafemarshaler/theproto3.proto"), + Package: func(v string) *string { return &v }("theproto3"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto", "github.com/gogo/protobuf/test/combos/both/thetest.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Message"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("hilarity"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".theproto3.Message.Humour"), + }, {Name: func(v string) *string { return &v }("height_in_cm"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("data"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("result_count"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("true_scotsman"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("score"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("nested"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Nested"), + }, {Name: func(v string) *string { return &v }("terrain"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Message.TerrainEntry"), + }, {Name: func(v string) *string { return &v }("proto2_field"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("proto2_value"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Message.Proto2ValueEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("TerrainEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Nested"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Proto2ValueEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Humour"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("UNKNOWN"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("PUNS"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("SLAPSTICK"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("BILL_BAILEY"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("Nested"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("bunny"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("AllMaps"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMap"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToDoubleMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToFloatMap"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToFloatMapEntry"), + }, {Name: func(v string) *string { return &v }("Int32Map"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Int32MapEntry"), + }, {Name: func(v string) *string { return &v }("Int64Map"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Int64MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint32Map"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Uint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint64Map"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Uint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint32Map"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint64Map"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed32Map"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Fixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed32Map"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sfixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed64Map"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Fixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed64Map"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sfixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("BoolMap"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.BoolMapEntry"), + }, {Name: func(v string) *string { return &v }("StringMap"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToBytesMap"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToBytesMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToEnumMap"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToEnumMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToMsgMap"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToMsgMapEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToFloatMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("BoolMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToBytesMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToEnumMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".theproto3.MapEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToMsgMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("MessageWithMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_mapping"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.NameMappingEntry"), + }, {Name: func(v string) *string { return &v }("msg_mapping"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.MsgMappingEntry"), + }, {Name: func(v string) *string { return &v }("byte_mapping"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.ByteMappingEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NameMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("MsgMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("ByteMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("FloatingPoint"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("f"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("MapEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("MA"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("MB"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("MC"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x1}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + Syntax: func(v string) *string { return &v }("proto3"), + }}, + } +} +func (x MapEnum) String() string { + s, ok := MapEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x Message_Humour) String() string { + s, ok := Message_Humour_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *Message) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Message) + if !ok { + return fmt.Errorf("that is not of type *Message") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Message but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Messagebut is not nil && this == nil") + } + if this.Name != that1.Name { + return fmt.Errorf("Name this(%v) Not Equal that(%v)", this.Name, that1.Name) + } + if this.Hilarity != that1.Hilarity { + return fmt.Errorf("Hilarity this(%v) Not Equal that(%v)", this.Hilarity, that1.Hilarity) + } + if this.HeightInCm != that1.HeightInCm { + return fmt.Errorf("HeightInCm this(%v) Not Equal that(%v)", this.HeightInCm, that1.HeightInCm) + } + if !bytes.Equal(this.Data, that1.Data) { + return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data) + } + if this.ResultCount != that1.ResultCount { + return fmt.Errorf("ResultCount this(%v) Not Equal that(%v)", this.ResultCount, that1.ResultCount) + } + if this.TrueScotsman != that1.TrueScotsman { + return fmt.Errorf("TrueScotsman this(%v) Not Equal that(%v)", this.TrueScotsman, that1.TrueScotsman) + } + if this.Score != that1.Score { + return fmt.Errorf("Score this(%v) Not Equal that(%v)", this.Score, that1.Score) + } + if len(this.Key) != len(that1.Key) { + return fmt.Errorf("Key this(%v) Not Equal that(%v)", len(this.Key), len(that1.Key)) + } + for i := range this.Key { + if this.Key[i] != that1.Key[i] { + return fmt.Errorf("Key this[%v](%v) Not Equal that[%v](%v)", i, this.Key[i], i, that1.Key[i]) + } + } + if !this.Nested.Equal(that1.Nested) { + return fmt.Errorf("Nested this(%v) Not Equal that(%v)", this.Nested, that1.Nested) + } + if len(this.Terrain) != len(that1.Terrain) { + return fmt.Errorf("Terrain this(%v) Not Equal that(%v)", len(this.Terrain), len(that1.Terrain)) + } + for i := range this.Terrain { + if !this.Terrain[i].Equal(that1.Terrain[i]) { + return fmt.Errorf("Terrain this[%v](%v) Not Equal that[%v](%v)", i, this.Terrain[i], i, that1.Terrain[i]) + } + } + if !this.Proto2Field.Equal(that1.Proto2Field) { + return fmt.Errorf("Proto2Field this(%v) Not Equal that(%v)", this.Proto2Field, that1.Proto2Field) + } + if len(this.Proto2Value) != len(that1.Proto2Value) { + return fmt.Errorf("Proto2Value this(%v) Not Equal that(%v)", len(this.Proto2Value), len(that1.Proto2Value)) + } + for i := range this.Proto2Value { + if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) { + return fmt.Errorf("Proto2Value this[%v](%v) Not Equal that[%v](%v)", i, this.Proto2Value[i], i, that1.Proto2Value[i]) + } + } + return nil +} +func (this *Message) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Message) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Name != that1.Name { + return false + } + if this.Hilarity != that1.Hilarity { + return false + } + if this.HeightInCm != that1.HeightInCm { + return false + } + if !bytes.Equal(this.Data, that1.Data) { + return false + } + if this.ResultCount != that1.ResultCount { + return false + } + if this.TrueScotsman != that1.TrueScotsman { + return false + } + if this.Score != that1.Score { + return false + } + if len(this.Key) != len(that1.Key) { + return false + } + for i := range this.Key { + if this.Key[i] != that1.Key[i] { + return false + } + } + if !this.Nested.Equal(that1.Nested) { + return false + } + if len(this.Terrain) != len(that1.Terrain) { + return false + } + for i := range this.Terrain { + if !this.Terrain[i].Equal(that1.Terrain[i]) { + return false + } + } + if !this.Proto2Field.Equal(that1.Proto2Field) { + return false + } + if len(this.Proto2Value) != len(that1.Proto2Value) { + return false + } + for i := range this.Proto2Value { + if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) { + return false + } + } + return true +} +func (this *Nested) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Nested) + if !ok { + return fmt.Errorf("that is not of type *Nested") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Nested but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Nestedbut is not nil && this == nil") + } + if this.Bunny != that1.Bunny { + return fmt.Errorf("Bunny this(%v) Not Equal that(%v)", this.Bunny, that1.Bunny) + } + return nil +} +func (this *Nested) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Nested) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Bunny != that1.Bunny { + return false + } + return true +} +func (this *AllMaps) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllMaps) + if !ok { + return fmt.Errorf("that is not of type *AllMaps") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllMaps but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllMapsbut is not nil && this == nil") + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap)) + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i]) + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap)) + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i]) + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map)) + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i]) + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map)) + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i]) + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map)) + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i]) + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map)) + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i]) + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map)) + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i]) + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map)) + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i]) + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map)) + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i]) + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map)) + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i]) + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map)) + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i]) + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map)) + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i]) + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap)) + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i]) + } + } + if len(this.StringMap) != len(that1.StringMap) { + return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap)) + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i]) + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap)) + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i]) + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap)) + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i]) + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap)) + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i]) + } + } + return nil +} +func (this *AllMaps) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllMaps) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return false + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return false + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return false + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return false + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return false + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return false + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return false + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return false + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return false + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return false + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return false + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return false + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return false + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return false + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return false + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return false + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return false + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return false + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return false + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return false + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return false + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return false + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return false + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return false + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return false + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return false + } + } + if len(this.StringMap) != len(that1.StringMap) { + return false + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return false + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return false + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return false + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return false + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return false + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return false + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return false + } + } + return true +} +func (this *MessageWithMap) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*MessageWithMap) + if !ok { + return fmt.Errorf("that is not of type *MessageWithMap") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *MessageWithMap but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *MessageWithMapbut is not nil && this == nil") + } + if len(this.NameMapping) != len(that1.NameMapping) { + return fmt.Errorf("NameMapping this(%v) Not Equal that(%v)", len(this.NameMapping), len(that1.NameMapping)) + } + for i := range this.NameMapping { + if this.NameMapping[i] != that1.NameMapping[i] { + return fmt.Errorf("NameMapping this[%v](%v) Not Equal that[%v](%v)", i, this.NameMapping[i], i, that1.NameMapping[i]) + } + } + if len(this.MsgMapping) != len(that1.MsgMapping) { + return fmt.Errorf("MsgMapping this(%v) Not Equal that(%v)", len(this.MsgMapping), len(that1.MsgMapping)) + } + for i := range this.MsgMapping { + if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) { + return fmt.Errorf("MsgMapping this[%v](%v) Not Equal that[%v](%v)", i, this.MsgMapping[i], i, that1.MsgMapping[i]) + } + } + if len(this.ByteMapping) != len(that1.ByteMapping) { + return fmt.Errorf("ByteMapping this(%v) Not Equal that(%v)", len(this.ByteMapping), len(that1.ByteMapping)) + } + for i := range this.ByteMapping { + if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) { + return fmt.Errorf("ByteMapping this[%v](%v) Not Equal that[%v](%v)", i, this.ByteMapping[i], i, that1.ByteMapping[i]) + } + } + return nil +} +func (this *MessageWithMap) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*MessageWithMap) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.NameMapping) != len(that1.NameMapping) { + return false + } + for i := range this.NameMapping { + if this.NameMapping[i] != that1.NameMapping[i] { + return false + } + } + if len(this.MsgMapping) != len(that1.MsgMapping) { + return false + } + for i := range this.MsgMapping { + if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) { + return false + } + } + if len(this.ByteMapping) != len(that1.ByteMapping) { + return false + } + for i := range this.ByteMapping { + if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) { + return false + } + } + return true +} +func (this *FloatingPoint) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return fmt.Errorf("that is not of type *FloatingPoint") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *FloatingPointbut is not nil && this == nil") + } + if this.F != that1.F { + return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F) + } + return nil +} +func (this *FloatingPoint) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.F != that1.F { + return false + } + return true +} + +type MessageFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetName() string + GetHilarity() Message_Humour + GetHeightInCm() uint32 + GetData() []byte + GetResultCount() int64 + GetTrueScotsman() bool + GetScore() float32 + GetKey() []uint64 + GetNested() *Nested + GetTerrain() map[int64]*Nested + GetProto2Field() *test.NinOptNative + GetProto2Value() map[int64]*test.NinOptEnum +} + +func (this *Message) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Message) TestProto() github_com_gogo_protobuf_proto.Message { + return NewMessageFromFace(this) +} + +func (this *Message) GetName() string { + return this.Name +} + +func (this *Message) GetHilarity() Message_Humour { + return this.Hilarity +} + +func (this *Message) GetHeightInCm() uint32 { + return this.HeightInCm +} + +func (this *Message) GetData() []byte { + return this.Data +} + +func (this *Message) GetResultCount() int64 { + return this.ResultCount +} + +func (this *Message) GetTrueScotsman() bool { + return this.TrueScotsman +} + +func (this *Message) GetScore() float32 { + return this.Score +} + +func (this *Message) GetKey() []uint64 { + return this.Key +} + +func (this *Message) GetNested() *Nested { + return this.Nested +} + +func (this *Message) GetTerrain() map[int64]*Nested { + return this.Terrain +} + +func (this *Message) GetProto2Field() *test.NinOptNative { + return this.Proto2Field +} + +func (this *Message) GetProto2Value() map[int64]*test.NinOptEnum { + return this.Proto2Value +} + +func NewMessageFromFace(that MessageFace) *Message { + this := &Message{} + this.Name = that.GetName() + this.Hilarity = that.GetHilarity() + this.HeightInCm = that.GetHeightInCm() + this.Data = that.GetData() + this.ResultCount = that.GetResultCount() + this.TrueScotsman = that.GetTrueScotsman() + this.Score = that.GetScore() + this.Key = that.GetKey() + this.Nested = that.GetNested() + this.Terrain = that.GetTerrain() + this.Proto2Field = that.GetProto2Field() + this.Proto2Value = that.GetProto2Value() + return this +} + +type NestedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetBunny() string +} + +func (this *Nested) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Nested) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedFromFace(this) +} + +func (this *Nested) GetBunny() string { + return this.Bunny +} + +func NewNestedFromFace(that NestedFace) *Nested { + this := &Nested{} + this.Bunny = that.GetBunny() + return this +} + +type AllMapsFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetStringToDoubleMap() map[string]float64 + GetStringToFloatMap() map[string]float32 + GetInt32Map() map[int32]int32 + GetInt64Map() map[int64]int64 + GetUint32Map() map[uint32]uint32 + GetUint64Map() map[uint64]uint64 + GetSint32Map() map[int32]int32 + GetSint64Map() map[int64]int64 + GetFixed32Map() map[uint32]uint32 + GetSfixed32Map() map[int32]int32 + GetFixed64Map() map[uint64]uint64 + GetSfixed64Map() map[int64]int64 + GetBoolMap() map[bool]bool + GetStringMap() map[string]string + GetStringToBytesMap() map[string][]byte + GetStringToEnumMap() map[string]MapEnum + GetStringToMsgMap() map[string]*FloatingPoint +} + +func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAllMapsFromFace(this) +} + +func (this *AllMaps) GetStringToDoubleMap() map[string]float64 { + return this.StringToDoubleMap +} + +func (this *AllMaps) GetStringToFloatMap() map[string]float32 { + return this.StringToFloatMap +} + +func (this *AllMaps) GetInt32Map() map[int32]int32 { + return this.Int32Map +} + +func (this *AllMaps) GetInt64Map() map[int64]int64 { + return this.Int64Map +} + +func (this *AllMaps) GetUint32Map() map[uint32]uint32 { + return this.Uint32Map +} + +func (this *AllMaps) GetUint64Map() map[uint64]uint64 { + return this.Uint64Map +} + +func (this *AllMaps) GetSint32Map() map[int32]int32 { + return this.Sint32Map +} + +func (this *AllMaps) GetSint64Map() map[int64]int64 { + return this.Sint64Map +} + +func (this *AllMaps) GetFixed32Map() map[uint32]uint32 { + return this.Fixed32Map +} + +func (this *AllMaps) GetSfixed32Map() map[int32]int32 { + return this.Sfixed32Map +} + +func (this *AllMaps) GetFixed64Map() map[uint64]uint64 { + return this.Fixed64Map +} + +func (this *AllMaps) GetSfixed64Map() map[int64]int64 { + return this.Sfixed64Map +} + +func (this *AllMaps) GetBoolMap() map[bool]bool { + return this.BoolMap +} + +func (this *AllMaps) GetStringMap() map[string]string { + return this.StringMap +} + +func (this *AllMaps) GetStringToBytesMap() map[string][]byte { + return this.StringToBytesMap +} + +func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum { + return this.StringToEnumMap +} + +func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint { + return this.StringToMsgMap +} + +func NewAllMapsFromFace(that AllMapsFace) *AllMaps { + this := &AllMaps{} + this.StringToDoubleMap = that.GetStringToDoubleMap() + this.StringToFloatMap = that.GetStringToFloatMap() + this.Int32Map = that.GetInt32Map() + this.Int64Map = that.GetInt64Map() + this.Uint32Map = that.GetUint32Map() + this.Uint64Map = that.GetUint64Map() + this.Sint32Map = that.GetSint32Map() + this.Sint64Map = that.GetSint64Map() + this.Fixed32Map = that.GetFixed32Map() + this.Sfixed32Map = that.GetSfixed32Map() + this.Fixed64Map = that.GetFixed64Map() + this.Sfixed64Map = that.GetSfixed64Map() + this.BoolMap = that.GetBoolMap() + this.StringMap = that.GetStringMap() + this.StringToBytesMap = that.GetStringToBytesMap() + this.StringToEnumMap = that.GetStringToEnumMap() + this.StringToMsgMap = that.GetStringToMsgMap() + return this +} + +type MessageWithMapFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNameMapping() map[int32]string + GetMsgMapping() map[int64]*FloatingPoint + GetByteMapping() map[bool][]byte +} + +func (this *MessageWithMap) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *MessageWithMap) TestProto() github_com_gogo_protobuf_proto.Message { + return NewMessageWithMapFromFace(this) +} + +func (this *MessageWithMap) GetNameMapping() map[int32]string { + return this.NameMapping +} + +func (this *MessageWithMap) GetMsgMapping() map[int64]*FloatingPoint { + return this.MsgMapping +} + +func (this *MessageWithMap) GetByteMapping() map[bool][]byte { + return this.ByteMapping +} + +func NewMessageWithMapFromFace(that MessageWithMapFace) *MessageWithMap { + this := &MessageWithMap{} + this.NameMapping = that.GetNameMapping() + this.MsgMapping = that.GetMsgMapping() + this.ByteMapping = that.GetByteMapping() + return this +} + +type FloatingPointFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetF() float64 +} + +func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message { + return NewFloatingPointFromFace(this) +} + +func (this *FloatingPoint) GetF() float64 { + return this.F +} + +func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint { + this := &FloatingPoint{} + this.F = that.GetF() + return this +} + +func (this *Message) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 16) + s = append(s, "&theproto3.Message{") + s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n") + s = append(s, "Hilarity: "+fmt.Sprintf("%#v", this.Hilarity)+",\n") + s = append(s, "HeightInCm: "+fmt.Sprintf("%#v", this.HeightInCm)+",\n") + s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") + s = append(s, "ResultCount: "+fmt.Sprintf("%#v", this.ResultCount)+",\n") + s = append(s, "TrueScotsman: "+fmt.Sprintf("%#v", this.TrueScotsman)+",\n") + s = append(s, "Score: "+fmt.Sprintf("%#v", this.Score)+",\n") + s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n") + if this.Nested != nil { + s = append(s, "Nested: "+fmt.Sprintf("%#v", this.Nested)+",\n") + } + keysForTerrain := make([]int64, 0, len(this.Terrain)) + for k := range this.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + mapStringForTerrain := "map[int64]*Nested{" + for _, k := range keysForTerrain { + mapStringForTerrain += fmt.Sprintf("%#v: %#v,", k, this.Terrain[k]) + } + mapStringForTerrain += "}" + if this.Terrain != nil { + s = append(s, "Terrain: "+mapStringForTerrain+",\n") + } + if this.Proto2Field != nil { + s = append(s, "Proto2Field: "+fmt.Sprintf("%#v", this.Proto2Field)+",\n") + } + keysForProto2Value := make([]int64, 0, len(this.Proto2Value)) + for k := range this.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + mapStringForProto2Value := "map[int64]*test.NinOptEnum{" + for _, k := range keysForProto2Value { + mapStringForProto2Value += fmt.Sprintf("%#v: %#v,", k, this.Proto2Value[k]) + } + mapStringForProto2Value += "}" + if this.Proto2Value != nil { + s = append(s, "Proto2Value: "+mapStringForProto2Value+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Nested) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&theproto3.Nested{") + s = append(s, "Bunny: "+fmt.Sprintf("%#v", this.Bunny)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllMaps) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 21) + s = append(s, "&theproto3.AllMaps{") + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + if this.StringToDoubleMap != nil { + s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n") + } + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + if this.StringToFloatMap != nil { + s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n") + } + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + if this.Int32Map != nil { + s = append(s, "Int32Map: "+mapStringForInt32Map+",\n") + } + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + if this.Int64Map != nil { + s = append(s, "Int64Map: "+mapStringForInt64Map+",\n") + } + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + if this.Uint32Map != nil { + s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n") + } + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + if this.Uint64Map != nil { + s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n") + } + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + if this.Sint32Map != nil { + s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n") + } + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + if this.Sint64Map != nil { + s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n") + } + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + if this.Fixed32Map != nil { + s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n") + } + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + if this.Sfixed32Map != nil { + s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n") + } + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + if this.Fixed64Map != nil { + s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n") + } + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + if this.Sfixed64Map != nil { + s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n") + } + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + if this.BoolMap != nil { + s = append(s, "BoolMap: "+mapStringForBoolMap+",\n") + } + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + if this.StringMap != nil { + s = append(s, "StringMap: "+mapStringForStringMap+",\n") + } + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + if this.StringToBytesMap != nil { + s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n") + } + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + if this.StringToEnumMap != nil { + s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n") + } + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + if this.StringToMsgMap != nil { + s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MessageWithMap) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&theproto3.MessageWithMap{") + keysForNameMapping := make([]int32, 0, len(this.NameMapping)) + for k := range this.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + mapStringForNameMapping := "map[int32]string{" + for _, k := range keysForNameMapping { + mapStringForNameMapping += fmt.Sprintf("%#v: %#v,", k, this.NameMapping[k]) + } + mapStringForNameMapping += "}" + if this.NameMapping != nil { + s = append(s, "NameMapping: "+mapStringForNameMapping+",\n") + } + keysForMsgMapping := make([]int64, 0, len(this.MsgMapping)) + for k := range this.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + mapStringForMsgMapping := "map[int64]*FloatingPoint{" + for _, k := range keysForMsgMapping { + mapStringForMsgMapping += fmt.Sprintf("%#v: %#v,", k, this.MsgMapping[k]) + } + mapStringForMsgMapping += "}" + if this.MsgMapping != nil { + s = append(s, "MsgMapping: "+mapStringForMsgMapping+",\n") + } + keysForByteMapping := make([]bool, 0, len(this.ByteMapping)) + for k := range this.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + mapStringForByteMapping := "map[bool][]byte{" + for _, k := range keysForByteMapping { + mapStringForByteMapping += fmt.Sprintf("%#v: %#v,", k, this.ByteMapping[k]) + } + mapStringForByteMapping += "}" + if this.ByteMapping != nil { + s = append(s, "ByteMapping: "+mapStringForByteMapping+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FloatingPoint) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&theproto3.FloatingPoint{") + s = append(s, "F: "+fmt.Sprintf("%#v", this.F)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringTheproto3(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringTheproto3(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedMessage(r randyTheproto3, easy bool) *Message { + this := &Message{} + this.Name = randStringTheproto3(r) + this.Hilarity = Message_Humour([]int32{0, 1, 2, 3}[r.Intn(4)]) + this.HeightInCm = uint32(r.Uint32()) + v1 := r.Intn(100) + this.Data = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Data[i] = byte(r.Intn(256)) + } + this.ResultCount = int64(r.Int63()) + if r.Intn(2) == 0 { + this.ResultCount *= -1 + } + this.TrueScotsman = bool(bool(r.Intn(2) == 0)) + this.Score = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Score *= -1 + } + v2 := r.Intn(100) + this.Key = make([]uint64, v2) + for i := 0; i < v2; i++ { + this.Key[i] = uint64(uint64(r.Uint32())) + } + if r.Intn(10) != 0 { + this.Nested = NewPopulatedNested(r, easy) + } + if r.Intn(10) != 0 { + v3 := r.Intn(10) + this.Terrain = make(map[int64]*Nested) + for i := 0; i < v3; i++ { + this.Terrain[int64(r.Int63())] = NewPopulatedNested(r, easy) + } + } + if r.Intn(10) != 0 { + this.Proto2Field = test.NewPopulatedNinOptNative(r, easy) + } + if r.Intn(10) != 0 { + v4 := r.Intn(10) + this.Proto2Value = make(map[int64]*test.NinOptEnum) + for i := 0; i < v4; i++ { + this.Proto2Value[int64(r.Int63())] = test.NewPopulatedNinOptEnum(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedNested(r randyTheproto3, easy bool) *Nested { + this := &Nested{} + this.Bunny = randStringTheproto3(r) + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedAllMaps(r randyTheproto3, easy bool) *AllMaps { + this := &AllMaps{} + if r.Intn(10) != 0 { + v5 := r.Intn(10) + this.StringToDoubleMap = make(map[string]float64) + for i := 0; i < v5; i++ { + v6 := randStringTheproto3(r) + this.StringToDoubleMap[v6] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.StringToDoubleMap[v6] *= -1 + } + } + } + if r.Intn(10) != 0 { + v7 := r.Intn(10) + this.StringToFloatMap = make(map[string]float32) + for i := 0; i < v7; i++ { + v8 := randStringTheproto3(r) + this.StringToFloatMap[v8] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.StringToFloatMap[v8] *= -1 + } + } + } + if r.Intn(10) != 0 { + v9 := r.Intn(10) + this.Int32Map = make(map[int32]int32) + for i := 0; i < v9; i++ { + v10 := int32(r.Int31()) + this.Int32Map[v10] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Int32Map[v10] *= -1 + } + } + } + if r.Intn(10) != 0 { + v11 := r.Intn(10) + this.Int64Map = make(map[int64]int64) + for i := 0; i < v11; i++ { + v12 := int64(r.Int63()) + this.Int64Map[v12] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Int64Map[v12] *= -1 + } + } + } + if r.Intn(10) != 0 { + v13 := r.Intn(10) + this.Uint32Map = make(map[uint32]uint32) + for i := 0; i < v13; i++ { + v14 := uint32(r.Uint32()) + this.Uint32Map[v14] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v15 := r.Intn(10) + this.Uint64Map = make(map[uint64]uint64) + for i := 0; i < v15; i++ { + v16 := uint64(uint64(r.Uint32())) + this.Uint64Map[v16] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v17 := r.Intn(10) + this.Sint32Map = make(map[int32]int32) + for i := 0; i < v17; i++ { + v18 := int32(r.Int31()) + this.Sint32Map[v18] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sint32Map[v18] *= -1 + } + } + } + if r.Intn(10) != 0 { + v19 := r.Intn(10) + this.Sint64Map = make(map[int64]int64) + for i := 0; i < v19; i++ { + v20 := int64(r.Int63()) + this.Sint64Map[v20] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sint64Map[v20] *= -1 + } + } + } + if r.Intn(10) != 0 { + v21 := r.Intn(10) + this.Fixed32Map = make(map[uint32]uint32) + for i := 0; i < v21; i++ { + v22 := uint32(r.Uint32()) + this.Fixed32Map[v22] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v23 := r.Intn(10) + this.Sfixed32Map = make(map[int32]int32) + for i := 0; i < v23; i++ { + v24 := int32(r.Int31()) + this.Sfixed32Map[v24] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sfixed32Map[v24] *= -1 + } + } + } + if r.Intn(10) != 0 { + v25 := r.Intn(10) + this.Fixed64Map = make(map[uint64]uint64) + for i := 0; i < v25; i++ { + v26 := uint64(uint64(r.Uint32())) + this.Fixed64Map[v26] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v27 := r.Intn(10) + this.Sfixed64Map = make(map[int64]int64) + for i := 0; i < v27; i++ { + v28 := int64(r.Int63()) + this.Sfixed64Map[v28] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sfixed64Map[v28] *= -1 + } + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(10) + this.BoolMap = make(map[bool]bool) + for i := 0; i < v29; i++ { + v30 := bool(bool(r.Intn(2) == 0)) + this.BoolMap[v30] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v31 := r.Intn(10) + this.StringMap = make(map[string]string) + for i := 0; i < v31; i++ { + this.StringMap[randStringTheproto3(r)] = randStringTheproto3(r) + } + } + if r.Intn(10) != 0 { + v32 := r.Intn(10) + this.StringToBytesMap = make(map[string][]byte) + for i := 0; i < v32; i++ { + v33 := r.Intn(100) + v34 := randStringTheproto3(r) + this.StringToBytesMap[v34] = make([]byte, v33) + for i := 0; i < v33; i++ { + this.StringToBytesMap[v34][i] = byte(r.Intn(256)) + } + } + } + if r.Intn(10) != 0 { + v35 := r.Intn(10) + this.StringToEnumMap = make(map[string]MapEnum) + for i := 0; i < v35; i++ { + this.StringToEnumMap[randStringTheproto3(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if r.Intn(10) != 0 { + v36 := r.Intn(10) + this.StringToMsgMap = make(map[string]*FloatingPoint) + for i := 0; i < v36; i++ { + this.StringToMsgMap[randStringTheproto3(r)] = NewPopulatedFloatingPoint(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedMessageWithMap(r randyTheproto3, easy bool) *MessageWithMap { + this := &MessageWithMap{} + if r.Intn(10) != 0 { + v37 := r.Intn(10) + this.NameMapping = make(map[int32]string) + for i := 0; i < v37; i++ { + this.NameMapping[int32(r.Int31())] = randStringTheproto3(r) + } + } + if r.Intn(10) != 0 { + v38 := r.Intn(10) + this.MsgMapping = make(map[int64]*FloatingPoint) + for i := 0; i < v38; i++ { + this.MsgMapping[int64(r.Int63())] = NewPopulatedFloatingPoint(r, easy) + } + } + if r.Intn(10) != 0 { + v39 := r.Intn(10) + this.ByteMapping = make(map[bool][]byte) + for i := 0; i < v39; i++ { + v40 := r.Intn(100) + v41 := bool(bool(r.Intn(2) == 0)) + this.ByteMapping[v41] = make([]byte, v40) + for i := 0; i < v40; i++ { + this.ByteMapping[v41][i] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedFloatingPoint(r randyTheproto3, easy bool) *FloatingPoint { + this := &FloatingPoint{} + this.F = float64(r.Float64()) + if r.Intn(2) == 0 { + this.F *= -1 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +type randyTheproto3 interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneTheproto3(r randyTheproto3) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringTheproto3(r randyTheproto3) string { + v42 := r.Intn(100) + tmps := make([]rune, v42) + for i := 0; i < v42; i++ { + tmps[i] = randUTF8RuneTheproto3(r) + } + return string(tmps) +} +func randUnrecognizedTheproto3(r randyTheproto3, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldTheproto3(data, r, fieldNumber, wire) + } + return data +} +func randFieldTheproto3(data []byte, r randyTheproto3, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + v43 := r.Int63() + if r.Intn(2) == 0 { + v43 *= -1 + } + data = encodeVarintPopulateTheproto3(data, uint64(v43)) + case 1: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateTheproto3(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateTheproto3(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Message) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + if m.Hilarity != 0 { + n += 1 + sovTheproto3(uint64(m.Hilarity)) + } + if m.HeightInCm != 0 { + n += 1 + sovTheproto3(uint64(m.HeightInCm)) + } + if m.Data != nil { + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + } + if m.ResultCount != 0 { + n += 1 + sovTheproto3(uint64(m.ResultCount)) + } + if m.TrueScotsman { + n += 2 + } + if m.Score != 0 { + n += 5 + } + if len(m.Key) > 0 { + for _, e := range m.Key { + n += 1 + sovTheproto3(uint64(e)) + } + } + if m.Nested != nil { + l = m.Nested.Size() + n += 1 + l + sovTheproto3(uint64(l)) + } + if len(m.Terrain) > 0 { + for k, v := range m.Terrain { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if m.Proto2Field != nil { + l = m.Proto2Field.Size() + n += 1 + l + sovTheproto3(uint64(l)) + } + if len(m.Proto2Value) > 0 { + for k, v := range m.Proto2Value { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *Nested) Size() (n int) { + var l int + _ = l + l = len(m.Bunny) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + return n +} + +func (m *AllMaps) Size() (n int) { + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + for k, v := range m.StringToDoubleMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToFloatMap) > 0 { + for k, v := range m.StringToFloatMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Int32Map) > 0 { + for k, v := range m.Int32Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Int64Map) > 0 { + for k, v := range m.Int64Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Uint32Map) > 0 { + for k, v := range m.Uint32Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Uint64Map) > 0 { + for k, v := range m.Uint64Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sint32Map) > 0 { + for k, v := range m.Sint32Map { + _ = k + _ = v + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sint64Map) > 0 { + for k, v := range m.Sint64Map { + _ = k + _ = v + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Fixed32Map) > 0 { + for k, v := range m.Fixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sfixed32Map) > 0 { + for k, v := range m.Sfixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Fixed64Map) > 0 { + for k, v := range m.Fixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sfixed64Map) > 0 { + for k, v := range m.Sfixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.BoolMap) > 0 { + for k, v := range m.BoolMap { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + 1 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringMap) > 0 { + for k, v := range m.StringMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToBytesMap) > 0 { + for k, v := range m.StringToBytesMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToEnumMap) > 0 { + for k, v := range m.StringToEnumMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToMsgMap) > 0 { + for k, v := range m.StringToMsgMap { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *MessageWithMap) Size() (n int) { + var l int + _ = l + if len(m.NameMapping) > 0 { + for k, v := range m.NameMapping { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.MsgMapping) > 0 { + for k, v := range m.MsgMapping { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.ByteMapping) > 0 { + for k, v := range m.ByteMapping { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *FloatingPoint) Size() (n int) { + var l int + _ = l + if m.F != 0 { + n += 9 + } + return n +} + +func sovTheproto3(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozTheproto3(x uint64) (n int) { + return sovTheproto3(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Message) String() string { + if this == nil { + return "nil" + } + keysForTerrain := make([]int64, 0, len(this.Terrain)) + for k := range this.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + mapStringForTerrain := "map[int64]*Nested{" + for _, k := range keysForTerrain { + mapStringForTerrain += fmt.Sprintf("%v: %v,", k, this.Terrain[k]) + } + mapStringForTerrain += "}" + keysForProto2Value := make([]int64, 0, len(this.Proto2Value)) + for k := range this.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + mapStringForProto2Value := "map[int64]*test.NinOptEnum{" + for _, k := range keysForProto2Value { + mapStringForProto2Value += fmt.Sprintf("%v: %v,", k, this.Proto2Value[k]) + } + mapStringForProto2Value += "}" + s := strings.Join([]string{`&Message{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Hilarity:` + fmt.Sprintf("%v", this.Hilarity) + `,`, + `HeightInCm:` + fmt.Sprintf("%v", this.HeightInCm) + `,`, + `Data:` + fmt.Sprintf("%v", this.Data) + `,`, + `ResultCount:` + fmt.Sprintf("%v", this.ResultCount) + `,`, + `TrueScotsman:` + fmt.Sprintf("%v", this.TrueScotsman) + `,`, + `Score:` + fmt.Sprintf("%v", this.Score) + `,`, + `Key:` + fmt.Sprintf("%v", this.Key) + `,`, + `Nested:` + strings.Replace(fmt.Sprintf("%v", this.Nested), "Nested", "Nested", 1) + `,`, + `Terrain:` + mapStringForTerrain + `,`, + `Proto2Field:` + strings.Replace(fmt.Sprintf("%v", this.Proto2Field), "NinOptNative", "test.NinOptNative", 1) + `,`, + `Proto2Value:` + mapStringForProto2Value + `,`, + `}`, + }, "") + return s +} +func (this *Nested) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Nested{`, + `Bunny:` + fmt.Sprintf("%v", this.Bunny) + `,`, + `}`, + }, "") + return s +} +func (this *AllMaps) String() string { + if this == nil { + return "nil" + } + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + s := strings.Join([]string{`&AllMaps{`, + `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`, + `StringToFloatMap:` + mapStringForStringToFloatMap + `,`, + `Int32Map:` + mapStringForInt32Map + `,`, + `Int64Map:` + mapStringForInt64Map + `,`, + `Uint32Map:` + mapStringForUint32Map + `,`, + `Uint64Map:` + mapStringForUint64Map + `,`, + `Sint32Map:` + mapStringForSint32Map + `,`, + `Sint64Map:` + mapStringForSint64Map + `,`, + `Fixed32Map:` + mapStringForFixed32Map + `,`, + `Sfixed32Map:` + mapStringForSfixed32Map + `,`, + `Fixed64Map:` + mapStringForFixed64Map + `,`, + `Sfixed64Map:` + mapStringForSfixed64Map + `,`, + `BoolMap:` + mapStringForBoolMap + `,`, + `StringMap:` + mapStringForStringMap + `,`, + `StringToBytesMap:` + mapStringForStringToBytesMap + `,`, + `StringToEnumMap:` + mapStringForStringToEnumMap + `,`, + `StringToMsgMap:` + mapStringForStringToMsgMap + `,`, + `}`, + }, "") + return s +} +func (this *MessageWithMap) String() string { + if this == nil { + return "nil" + } + keysForNameMapping := make([]int32, 0, len(this.NameMapping)) + for k := range this.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + mapStringForNameMapping := "map[int32]string{" + for _, k := range keysForNameMapping { + mapStringForNameMapping += fmt.Sprintf("%v: %v,", k, this.NameMapping[k]) + } + mapStringForNameMapping += "}" + keysForMsgMapping := make([]int64, 0, len(this.MsgMapping)) + for k := range this.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + mapStringForMsgMapping := "map[int64]*FloatingPoint{" + for _, k := range keysForMsgMapping { + mapStringForMsgMapping += fmt.Sprintf("%v: %v,", k, this.MsgMapping[k]) + } + mapStringForMsgMapping += "}" + keysForByteMapping := make([]bool, 0, len(this.ByteMapping)) + for k := range this.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + mapStringForByteMapping := "map[bool][]byte{" + for _, k := range keysForByteMapping { + mapStringForByteMapping += fmt.Sprintf("%v: %v,", k, this.ByteMapping[k]) + } + mapStringForByteMapping += "}" + s := strings.Join([]string{`&MessageWithMap{`, + `NameMapping:` + mapStringForNameMapping + `,`, + `MsgMapping:` + mapStringForMsgMapping + `,`, + `ByteMapping:` + mapStringForByteMapping + `,`, + `}`, + }, "") + return s +} +func (this *FloatingPoint) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FloatingPoint{`, + `F:` + fmt.Sprintf("%v", this.F) + `,`, + `}`, + }, "") + return s +} +func valueToStringTheproto3(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Message) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Message) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(m.Name))) + i += copy(data[i:], m.Name) + } + if m.Hilarity != 0 { + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(m.Hilarity)) + } + if m.HeightInCm != 0 { + data[i] = 0x18 + i++ + i = encodeVarintTheproto3(data, i, uint64(m.HeightInCm)) + } + if m.Data != nil { + if len(m.Data) > 0 { + data[i] = 0x22 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(m.Data))) + i += copy(data[i:], m.Data) + } + } + if len(m.Key) > 0 { + for _, num := range m.Key { + data[i] = 0x28 + i++ + i = encodeVarintTheproto3(data, i, uint64(num)) + } + } + if m.Nested != nil { + data[i] = 0x32 + i++ + i = encodeVarintTheproto3(data, i, uint64(m.Nested.Size())) + n1, err := m.Nested.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n1 + } + if m.ResultCount != 0 { + data[i] = 0x38 + i++ + i = encodeVarintTheproto3(data, i, uint64(m.ResultCount)) + } + if m.TrueScotsman { + data[i] = 0x40 + i++ + if m.TrueScotsman { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + if m.Score != 0 { + data[i] = 0x4d + i++ + *(*float32)(unsafe.Pointer(&data[i])) = m.Score + i += 4 + } + if len(m.Terrain) > 0 { + keysForTerrain := make([]int64, 0, len(m.Terrain)) + for k := range m.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + for _, k := range keysForTerrain { + data[i] = 0x52 + i++ + v := m.Terrain[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + msgSize + sovTheproto3(uint64(msgSize)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(v.Size())) + n2, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + } + } + if m.Proto2Field != nil { + data[i] = 0x5a + i++ + i = encodeVarintTheproto3(data, i, uint64(m.Proto2Field.Size())) + n3, err := m.Proto2Field.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n3 + } + if len(m.Proto2Value) > 0 { + keysForProto2Value := make([]int64, 0, len(m.Proto2Value)) + for k := range m.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + for _, k := range keysForProto2Value { + data[i] = 0x6a + i++ + v := m.Proto2Value[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + msgSize + sovTheproto3(uint64(msgSize)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(v.Size())) + n4, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n4 + } + } + return i, nil +} + +func (m *Nested) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Nested) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Bunny) > 0 { + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(m.Bunny))) + i += copy(data[i:], m.Bunny) + } + return i, nil +} + +func (m *AllMaps) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *AllMaps) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + keysForStringToDoubleMap := make([]string, 0, len(m.StringToDoubleMap)) + for k := range m.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + for _, k := range keysForStringToDoubleMap { + data[i] = 0xa + i++ + v := m.StringToDoubleMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x11 + i++ + i = encodeFixed64Theproto3(data, i, uint64(math.Float64bits(v))) + } + } + if len(m.StringToFloatMap) > 0 { + keysForStringToFloatMap := make([]string, 0, len(m.StringToFloatMap)) + for k := range m.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + for _, k := range keysForStringToFloatMap { + data[i] = 0x12 + i++ + v := m.StringToFloatMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x15 + i++ + i = encodeFixed32Theproto3(data, i, uint32(math.Float32bits(v))) + } + } + if len(m.Int32Map) > 0 { + keysForInt32Map := make([]int32, 0, len(m.Int32Map)) + for k := range m.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + for _, k := range keysForInt32Map { + data[i] = 0x1a + i++ + v := m.Int32Map[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.Int64Map) > 0 { + keysForInt64Map := make([]int64, 0, len(m.Int64Map)) + for k := range m.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + for _, k := range keysForInt64Map { + data[i] = 0x22 + i++ + v := m.Int64Map[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.Uint32Map) > 0 { + keysForUint32Map := make([]uint32, 0, len(m.Uint32Map)) + for k := range m.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + for _, k := range keysForUint32Map { + data[i] = 0x2a + i++ + v := m.Uint32Map[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.Uint64Map) > 0 { + keysForUint64Map := make([]uint64, 0, len(m.Uint64Map)) + for k := range m.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + for _, k := range keysForUint64Map { + data[i] = 0x32 + i++ + v := m.Uint64Map[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.Sint32Map) > 0 { + keysForSint32Map := make([]int32, 0, len(m.Sint32Map)) + for k := range m.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + for _, k := range keysForSint32Map { + data[i] = 0x3a + i++ + v := m.Sint32Map[k] + mapSize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint32(k)<<1)^uint32((k>>31)))) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint32(v)<<1)^uint32((v>>31)))) + } + } + if len(m.Sint64Map) > 0 { + keysForSint64Map := make([]int64, 0, len(m.Sint64Map)) + for k := range m.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + for _, k := range keysForSint64Map { + data[i] = 0x42 + i++ + v := m.Sint64Map[k] + mapSize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint64(k)<<1)^uint64((k>>63)))) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint64(v)<<1)^uint64((v>>63)))) + } + } + if len(m.Fixed32Map) > 0 { + keysForFixed32Map := make([]uint32, 0, len(m.Fixed32Map)) + for k := range m.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + for _, k := range keysForFixed32Map { + data[i] = 0x4a + i++ + v := m.Fixed32Map[k] + mapSize := 1 + 4 + 1 + 4 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xd + i++ + i = encodeFixed32Theproto3(data, i, uint32(k)) + data[i] = 0x15 + i++ + i = encodeFixed32Theproto3(data, i, uint32(v)) + } + } + if len(m.Sfixed32Map) > 0 { + keysForSfixed32Map := make([]int32, 0, len(m.Sfixed32Map)) + for k := range m.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + for _, k := range keysForSfixed32Map { + data[i] = 0x52 + i++ + v := m.Sfixed32Map[k] + mapSize := 1 + 4 + 1 + 4 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xd + i++ + i = encodeFixed32Theproto3(data, i, uint32(k)) + data[i] = 0x15 + i++ + i = encodeFixed32Theproto3(data, i, uint32(v)) + } + } + if len(m.Fixed64Map) > 0 { + keysForFixed64Map := make([]uint64, 0, len(m.Fixed64Map)) + for k := range m.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + for _, k := range keysForFixed64Map { + data[i] = 0x5a + i++ + v := m.Fixed64Map[k] + mapSize := 1 + 8 + 1 + 8 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x9 + i++ + i = encodeFixed64Theproto3(data, i, uint64(k)) + data[i] = 0x11 + i++ + i = encodeFixed64Theproto3(data, i, uint64(v)) + } + } + if len(m.Sfixed64Map) > 0 { + keysForSfixed64Map := make([]int64, 0, len(m.Sfixed64Map)) + for k := range m.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + for _, k := range keysForSfixed64Map { + data[i] = 0x62 + i++ + v := m.Sfixed64Map[k] + mapSize := 1 + 8 + 1 + 8 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x9 + i++ + i = encodeFixed64Theproto3(data, i, uint64(k)) + data[i] = 0x11 + i++ + i = encodeFixed64Theproto3(data, i, uint64(v)) + } + } + if len(m.BoolMap) > 0 { + keysForBoolMap := make([]bool, 0, len(m.BoolMap)) + for k := range m.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + for _, k := range keysForBoolMap { + data[i] = 0x6a + i++ + v := m.BoolMap[k] + mapSize := 1 + 1 + 1 + 1 + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + if k { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x10 + i++ + if v { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + } + } + if len(m.StringMap) > 0 { + keysForStringMap := make([]string, 0, len(m.StringMap)) + for k := range m.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + for _, k := range keysForStringMap { + data[i] = 0x72 + i++ + v := m.StringMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.StringToBytesMap) > 0 { + keysForStringToBytesMap := make([]string, 0, len(m.StringToBytesMap)) + for k := range m.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + for _, k := range keysForStringToBytesMap { + data[i] = 0x7a + i++ + v := m.StringToBytesMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.StringToEnumMap) > 0 { + keysForStringToEnumMap := make([]string, 0, len(m.StringToEnumMap)) + for k := range m.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + for _, k := range keysForStringToEnumMap { + data[i] = 0x82 + i++ + data[i] = 0x1 + i++ + v := m.StringToEnumMap[k] + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x10 + i++ + i = encodeVarintTheproto3(data, i, uint64(v)) + } + } + if len(m.StringToMsgMap) > 0 { + keysForStringToMsgMap := make([]string, 0, len(m.StringToMsgMap)) + for k := range m.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + for _, k := range keysForStringToMsgMap { + data[i] = 0x8a + i++ + data[i] = 0x1 + i++ + v := m.StringToMsgMap[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + msgSize + sovTheproto3(uint64(msgSize)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0xa + i++ + i = encodeVarintTheproto3(data, i, uint64(len(k))) + i += copy(data[i:], k) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(v.Size())) + n5, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n5 + } + } + return i, nil +} + +func (m *MessageWithMap) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *MessageWithMap) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.NameMapping) > 0 { + keysForNameMapping := make([]int32, 0, len(m.NameMapping)) + for k := range m.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + for _, k := range keysForNameMapping { + data[i] = 0xa + i++ + v := m.NameMapping[k] + mapSize := 1 + sovTheproto3(uint64(k)) + 1 + len(v) + sovTheproto3(uint64(len(v))) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64(k)) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + if len(m.MsgMapping) > 0 { + keysForMsgMapping := make([]int64, 0, len(m.MsgMapping)) + for k := range m.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + for _, k := range keysForMsgMapping { + data[i] = 0x12 + i++ + v := m.MsgMapping[k] + if v == nil { + return 0, errors.New("proto: map has nil element") + } + msgSize := v.Size() + mapSize := 1 + sozTheproto3(uint64(k)) + 1 + msgSize + sovTheproto3(uint64(msgSize)) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + i = encodeVarintTheproto3(data, i, uint64((uint64(k)<<1)^uint64((k>>63)))) + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(v.Size())) + n6, err := v.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n6 + } + } + if len(m.ByteMapping) > 0 { + keysForByteMapping := make([]bool, 0, len(m.ByteMapping)) + for k := range m.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + for _, k := range keysForByteMapping { + data[i] = 0x1a + i++ + v := m.ByteMapping[k] + mapSize := 1 + 1 + 1 + len(v) + sovTheproto3(uint64(len(v))) + i = encodeVarintTheproto3(data, i, uint64(mapSize)) + data[i] = 0x8 + i++ + if k { + data[i] = 1 + } else { + data[i] = 0 + } + i++ + data[i] = 0x12 + i++ + i = encodeVarintTheproto3(data, i, uint64(len(v))) + i += copy(data[i:], v) + } + } + return i, nil +} + +func (m *FloatingPoint) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *FloatingPoint) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.F != 0 { + data[i] = 0x9 + i++ + *(*float64)(unsafe.Pointer(&data[i])) = m.F + i += 8 + } + return i, nil +} + +func encodeFixed64Theproto3(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Theproto3(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintTheproto3(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafemarshaler/theproto3.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafemarshaler/theproto3.proto new file mode 100644 index 0000000000000000000000000000000000000000..0c47048ce353fec996d925c85a1324273612ee23 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafemarshaler/theproto3.proto @@ -0,0 +1,129 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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 theproto3; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +import "github.com/gogo/protobuf/test/combos/both/thetest.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = true; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Message { + enum Humour { + UNKNOWN = 0; + PUNS = 1; + SLAPSTICK = 2; + BILL_BAILEY = 3; + } + + string name = 1; + Humour hilarity = 2; + uint32 height_in_cm = 3; + bytes data = 4; + int64 result_count = 7; + bool true_scotsman = 8; + float score = 9; + + repeated uint64 key = 5; + Nested nested = 6; + + map terrain = 10; + test.NinOptNative proto2_field = 11; + map proto2_value = 13; +} + +message Nested { + string bunny = 1; +} + +enum MapEnum { + MA = 0; + MB = 1; + MC = 2; +} + +message AllMaps { + map StringToDoubleMap = 1; + map StringToFloatMap = 2; + map Int32Map = 3; + map Int64Map = 4; + map Uint32Map = 5; + map Uint64Map = 6; + map Sint32Map = 7; + map Sint64Map = 8; + map Fixed32Map = 9; + map Sfixed32Map = 10; + map Fixed64Map = 11; + map Sfixed64Map = 12; + map BoolMap = 13; + map StringMap = 14; + map StringToBytesMap = 15; + map StringToEnumMap = 16; + map StringToMsgMap = 17; +} + +message MessageWithMap { + map name_mapping = 1; + map msg_mapping = 2; + map byte_mapping = 3; +} + +message FloatingPoint { + double f = 1; +} \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafemarshaler/theproto3pb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafemarshaler/theproto3pb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..af2e76d934b26528158b45b1002dfd7d85d508e1 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafemarshaler/theproto3pb_test.go @@ -0,0 +1,1232 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafemarshaler/theproto3.proto +// DO NOT EDIT! + +/* +Package theproto3 is a generated protocol buffer package. + +It is generated from these files: + combos/unsafemarshaler/theproto3.proto + +It has these top-level messages: + Message + Nested + AllMaps + MessageWithMap + FloatingPoint +*/ +package theproto3 + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" +// discarding unused import test "github.com/gogo/protobuf/test/combos/both" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestMessageProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestMessageMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkMessageProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Message, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMessageProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessage(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Message{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNestedMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkNestedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nested, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNested(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNested(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Nested{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAllMapsMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkAllMapsProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMaps(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AllMaps{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageWithMapProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestMessageWithMapMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkMessageWithMapProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MessageWithMap, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMessageWithMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMessageWithMapProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessageWithMap(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &MessageWithMap{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestFloatingPointMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func BenchmarkFloatingPointProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedFloatingPoint(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &FloatingPoint{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllMapsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMessageWithMapJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestFloatingPointJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMessageProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Message{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Message{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageWithMapProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageWithMapProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTheproto3Description(t *testing.T) { + Theproto3Description() +} +func TestMessageVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllMapsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMessageWithMapVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestFloatingPointVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMessageFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAllMapsFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestMessageWithMapFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestFloatingPointFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestMessageGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllMapsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMessageWithMapGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestFloatingPointGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMessageSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMessageSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Message, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nested, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNested(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAllMapsSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageWithMapSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMessageWithMapSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MessageWithMap, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMessageWithMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkFloatingPointSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllMapsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestMessageWithMapStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestFloatingPointStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeunmarshaler/nilmaps_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeunmarshaler/nilmaps_test.go new file mode 100644 index 0000000000000000000000000000000000000000..1b05c72b2c453fe78cac35296c395d0dc5951bc8 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeunmarshaler/nilmaps_test.go @@ -0,0 +1,39 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 theproto3 + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "testing" +) + +func TestNilMaps(t *testing.T) { + m := &AllMaps{StringToMsgMap: map[string]*FloatingPoint{"a": nil}} + if _, err := proto.Marshal(m); err == nil { + t.Fatalf("expected error") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeunmarshaler/theproto3.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeunmarshaler/theproto3.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..12e7c303ffbaf053c2b78cecd3763c00498833df --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeunmarshaler/theproto3.pb.go @@ -0,0 +1,10352 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeunmarshaler/theproto3.proto +// DO NOT EDIT! + +/* + Package theproto3 is a generated protocol buffer package. + + It is generated from these files: + combos/unsafeunmarshaler/theproto3.proto + + It has these top-level messages: + Message + Nested + AllMaps + MessageWithMap + FloatingPoint +*/ +package theproto3 + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" +import test "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/combos/both" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" +import github_com_gogo_protobuf_sortkeys "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/sortkeys" + +import io "io" +import unsafe "unsafe" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type MapEnum int32 + +const ( + MA MapEnum = 0 + MB MapEnum = 1 + MC MapEnum = 2 +) + +var MapEnum_name = map[int32]string{ + 0: "MA", + 1: "MB", + 2: "MC", +} +var MapEnum_value = map[string]int32{ + "MA": 0, + "MB": 1, + "MC": 2, +} + +type Message_Humour int32 + +const ( + UNKNOWN Message_Humour = 0 + PUNS Message_Humour = 1 + SLAPSTICK Message_Humour = 2 + BILL_BAILEY Message_Humour = 3 +) + +var Message_Humour_name = map[int32]string{ + 0: "UNKNOWN", + 1: "PUNS", + 2: "SLAPSTICK", + 3: "BILL_BAILEY", +} +var Message_Humour_value = map[string]int32{ + "UNKNOWN": 0, + "PUNS": 1, + "SLAPSTICK": 2, + "BILL_BAILEY": 3, +} + +type Message struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Hilarity Message_Humour `protobuf:"varint,2,opt,name=hilarity,proto3,enum=theproto3.Message_Humour" json:"hilarity,omitempty"` + HeightInCm uint32 `protobuf:"varint,3,opt,name=height_in_cm,proto3" json:"height_in_cm,omitempty"` + Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` + ResultCount int64 `protobuf:"varint,7,opt,name=result_count,proto3" json:"result_count,omitempty"` + TrueScotsman bool `protobuf:"varint,8,opt,name=true_scotsman,proto3" json:"true_scotsman,omitempty"` + Score float32 `protobuf:"fixed32,9,opt,name=score,proto3" json:"score,omitempty"` + Key []uint64 `protobuf:"varint,5,rep,name=key" json:"key,omitempty"` + Nested *Nested `protobuf:"bytes,6,opt,name=nested" json:"nested,omitempty"` + Terrain map[int64]*Nested `protobuf:"bytes,10,rep,name=terrain" json:"terrain,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` + Proto2Field *test.NinOptNative `protobuf:"bytes,11,opt,name=proto2_field" json:"proto2_field,omitempty"` + Proto2Value map[int64]*test.NinOptEnum `protobuf:"bytes,13,rep,name=proto2_value" json:"proto2_value,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` +} + +func (m *Message) Reset() { *m = Message{} } +func (*Message) ProtoMessage() {} + +type Nested struct { + Bunny string `protobuf:"bytes,1,opt,name=bunny,proto3" json:"bunny,omitempty"` +} + +func (m *Nested) Reset() { *m = Nested{} } +func (*Nested) ProtoMessage() {} + +type AllMaps struct { + StringToDoubleMap map[string]float64 `protobuf:"bytes,1,rep,name=StringToDoubleMap" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + StringToFloatMap map[string]float32 `protobuf:"bytes,2,rep,name=StringToFloatMap" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Int32Map map[int32]int32 `protobuf:"bytes,3,rep,name=Int32Map" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Int64Map map[int64]int64 `protobuf:"bytes,4,rep,name=Int64Map" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Uint32Map map[uint32]uint32 `protobuf:"bytes,5,rep,name=Uint32Map" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Uint64Map map[uint64]uint64 `protobuf:"bytes,6,rep,name=Uint64Map" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Sint32Map map[int32]int32 `protobuf:"bytes,7,rep,name=Sint32Map" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key,proto3" protobuf_val:"zigzag32,2,opt,name=value,proto3"` + Sint64Map map[int64]int64 `protobuf:"bytes,8,rep,name=Sint64Map" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"` + Fixed32Map map[uint32]uint32 `protobuf:"bytes,9,rep,name=Fixed32Map" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Sfixed32Map map[int32]int32 `protobuf:"bytes,10,rep,name=Sfixed32Map" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"` + Fixed64Map map[uint64]uint64 `protobuf:"bytes,11,rep,name=Fixed64Map" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + Sfixed64Map map[int64]int64 `protobuf:"bytes,12,rep,name=Sfixed64Map" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"` + BoolMap map[bool]bool `protobuf:"bytes,13,rep,name=BoolMap" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + StringMap map[string]string `protobuf:"bytes,14,rep,name=StringMap" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + StringToBytesMap map[string][]byte `protobuf:"bytes,15,rep,name=StringToBytesMap" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + StringToEnumMap map[string]MapEnum `protobuf:"bytes,16,rep,name=StringToEnumMap" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=theproto3.MapEnum"` + StringToMsgMap map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` +} + +func (m *AllMaps) Reset() { *m = AllMaps{} } +func (*AllMaps) ProtoMessage() {} + +type MessageWithMap struct { + NameMapping map[int32]string `protobuf:"bytes,1,rep,name=name_mapping" json:"name_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + MsgMapping map[int64]*FloatingPoint `protobuf:"bytes,2,rep,name=msg_mapping" json:"msg_mapping,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"` + ByteMapping map[bool][]byte `protobuf:"bytes,3,rep,name=byte_mapping" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (m *MessageWithMap) Reset() { *m = MessageWithMap{} } +func (*MessageWithMap) ProtoMessage() {} + +type FloatingPoint struct { + F float64 `protobuf:"fixed64,1,opt,name=f,proto3" json:"f,omitempty"` +} + +func (m *FloatingPoint) Reset() { *m = FloatingPoint{} } +func (*FloatingPoint) ProtoMessage() {} + +func init() { + proto.RegisterEnum("theproto3.MapEnum", MapEnum_name, MapEnum_value) + proto.RegisterEnum("theproto3.Message_Humour", Message_Humour_name, Message_Humour_value) +} +func (this *Message) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *Nested) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *AllMaps) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *MessageWithMap) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func (this *FloatingPoint) Description() (desc *google_protobuf.FileDescriptorSet) { + return Theproto3Description() +} +func Theproto3Description() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/test/combos/both/thetest.proto"), + Package: func(v string) *string { return &v }("test"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NinRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NidOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }, {Name: func(v string) *string { return &v }("NidNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidRepStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStruct"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinRepStruct"), + }}, + }, {Name: func(v string) *string { return &v }("NidOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomDash"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x64, 0x61, 0x73, 0x68, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NidRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinOptStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinNestedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNativeUnion"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStructUnion"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStructUnion"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Tree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Or"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.OrBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Leaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("OrBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Leaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("StrValue"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepTree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.ADeepBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndDeepBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepLeaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("ADeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndDeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepLeaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Tree"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Nil")}, {Name: func(v string) *string { return &v }("NidOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NidRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + DefaultValue: func(v string) *string { return &v }("C"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + DefaultValue: func(v string) *string { return &v }("E"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Timer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Time1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Time2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Data"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("MyExtendable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("OtherExtenable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("M"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(14), + End: func(v int32) *int32 { return &v }(17), + }, {Start: func(v int32) *int32 { return &v }(10), + End: func(v int32) *int32 { return &v }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("NestedDefinition"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("EnumField"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("NM"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedMessage"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedField1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedMsg"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedField1"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("NestedEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_NESTED"), + Number: func(v int32) *int32 { return &v }(1), + }}, + }}, + }, {Name: func(v string) *string { return &v }("NestedScope"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("true"), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("CustomContainer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("CustomStruct"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptCustom"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x5, 0x46, 0x69, 0x65, 0x6c, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameCustomType"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Ids"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Values"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("CustomNameEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + }, {Name: func(v string) *string { return &v }("NoExtensionsMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0}), 64025: proto.NewExtension([]byte{0xc8, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Unrecognized"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithInner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithInner.Inner"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Inner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithEmbed"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithEmbed.Embedded"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Embedded"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("TheTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }, {Name: func(v string) *string { return &v }("AnotherTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("D"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("E"), + Number: func(v int32) *int32 { return &v }(11), + }}, + Options: &google_protobuf.EnumOptions{XXX_extensions: map[int32]proto.Extension{62001: proto.NewExtension([]byte{0x88, 0xa3, 0x1e, 0x0})}}, + }}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("FieldA"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldB"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldC"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldA1"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldB1"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldC1"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }, {Name: func(v string) *string { return &v }("combos/unsafeunmarshaler/theproto3.proto"), + Package: func(v string) *string { return &v }("theproto3"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto", "github.com/gogo/protobuf/test/combos/both/thetest.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Message"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("hilarity"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".theproto3.Message.Humour"), + }, {Name: func(v string) *string { return &v }("height_in_cm"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("data"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("result_count"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("true_scotsman"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("score"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("nested"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Nested"), + }, {Name: func(v string) *string { return &v }("terrain"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Message.TerrainEntry"), + }, {Name: func(v string) *string { return &v }("proto2_field"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("proto2_value"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Message.Proto2ValueEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("TerrainEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.Nested"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Proto2ValueEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Humour"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("UNKNOWN"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("PUNS"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("SLAPSTICK"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("BILL_BAILEY"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("Nested"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("bunny"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("AllMaps"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMap"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToDoubleMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToFloatMap"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToFloatMapEntry"), + }, {Name: func(v string) *string { return &v }("Int32Map"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Int32MapEntry"), + }, {Name: func(v string) *string { return &v }("Int64Map"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Int64MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint32Map"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Uint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Uint64Map"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Uint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint32Map"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sint32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sint64Map"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sint64MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed32Map"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Fixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed32Map"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sfixed32MapEntry"), + }, {Name: func(v string) *string { return &v }("Fixed64Map"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Fixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("Sfixed64Map"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.Sfixed64MapEntry"), + }, {Name: func(v string) *string { return &v }("BoolMap"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.BoolMapEntry"), + }, {Name: func(v string) *string { return &v }("StringMap"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToBytesMap"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToBytesMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToEnumMap"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToEnumMapEntry"), + }, {Name: func(v string) *string { return &v }("StringToMsgMap"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.AllMaps.StringToMsgMapEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("StringToDoubleMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToFloatMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Int64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Uint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sint64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed32MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Fixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Sfixed64MapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("BoolMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToBytesMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToEnumMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".theproto3.MapEnum"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("StringToMsgMapEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("MessageWithMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_mapping"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.NameMappingEntry"), + }, {Name: func(v string) *string { return &v }("msg_mapping"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.MsgMappingEntry"), + }, {Name: func(v string) *string { return &v }("byte_mapping"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.MessageWithMap.ByteMappingEntry"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NameMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("MsgMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".theproto3.FloatingPoint"), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("ByteMappingEntry"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("key"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{MapEntry: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("FloatingPoint"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("f"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("MapEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("MA"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("MB"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("MC"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x1})}}, + Syntax: func(v string) *string { return &v }("proto3"), + }}, + } +} +func (x MapEnum) String() string { + s, ok := MapEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x Message_Humour) String() string { + s, ok := Message_Humour_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *Message) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Message) + if !ok { + return fmt.Errorf("that is not of type *Message") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Message but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Messagebut is not nil && this == nil") + } + if this.Name != that1.Name { + return fmt.Errorf("Name this(%v) Not Equal that(%v)", this.Name, that1.Name) + } + if this.Hilarity != that1.Hilarity { + return fmt.Errorf("Hilarity this(%v) Not Equal that(%v)", this.Hilarity, that1.Hilarity) + } + if this.HeightInCm != that1.HeightInCm { + return fmt.Errorf("HeightInCm this(%v) Not Equal that(%v)", this.HeightInCm, that1.HeightInCm) + } + if !bytes.Equal(this.Data, that1.Data) { + return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data) + } + if this.ResultCount != that1.ResultCount { + return fmt.Errorf("ResultCount this(%v) Not Equal that(%v)", this.ResultCount, that1.ResultCount) + } + if this.TrueScotsman != that1.TrueScotsman { + return fmt.Errorf("TrueScotsman this(%v) Not Equal that(%v)", this.TrueScotsman, that1.TrueScotsman) + } + if this.Score != that1.Score { + return fmt.Errorf("Score this(%v) Not Equal that(%v)", this.Score, that1.Score) + } + if len(this.Key) != len(that1.Key) { + return fmt.Errorf("Key this(%v) Not Equal that(%v)", len(this.Key), len(that1.Key)) + } + for i := range this.Key { + if this.Key[i] != that1.Key[i] { + return fmt.Errorf("Key this[%v](%v) Not Equal that[%v](%v)", i, this.Key[i], i, that1.Key[i]) + } + } + if !this.Nested.Equal(that1.Nested) { + return fmt.Errorf("Nested this(%v) Not Equal that(%v)", this.Nested, that1.Nested) + } + if len(this.Terrain) != len(that1.Terrain) { + return fmt.Errorf("Terrain this(%v) Not Equal that(%v)", len(this.Terrain), len(that1.Terrain)) + } + for i := range this.Terrain { + if !this.Terrain[i].Equal(that1.Terrain[i]) { + return fmt.Errorf("Terrain this[%v](%v) Not Equal that[%v](%v)", i, this.Terrain[i], i, that1.Terrain[i]) + } + } + if !this.Proto2Field.Equal(that1.Proto2Field) { + return fmt.Errorf("Proto2Field this(%v) Not Equal that(%v)", this.Proto2Field, that1.Proto2Field) + } + if len(this.Proto2Value) != len(that1.Proto2Value) { + return fmt.Errorf("Proto2Value this(%v) Not Equal that(%v)", len(this.Proto2Value), len(that1.Proto2Value)) + } + for i := range this.Proto2Value { + if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) { + return fmt.Errorf("Proto2Value this[%v](%v) Not Equal that[%v](%v)", i, this.Proto2Value[i], i, that1.Proto2Value[i]) + } + } + return nil +} +func (this *Message) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Message) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Name != that1.Name { + return false + } + if this.Hilarity != that1.Hilarity { + return false + } + if this.HeightInCm != that1.HeightInCm { + return false + } + if !bytes.Equal(this.Data, that1.Data) { + return false + } + if this.ResultCount != that1.ResultCount { + return false + } + if this.TrueScotsman != that1.TrueScotsman { + return false + } + if this.Score != that1.Score { + return false + } + if len(this.Key) != len(that1.Key) { + return false + } + for i := range this.Key { + if this.Key[i] != that1.Key[i] { + return false + } + } + if !this.Nested.Equal(that1.Nested) { + return false + } + if len(this.Terrain) != len(that1.Terrain) { + return false + } + for i := range this.Terrain { + if !this.Terrain[i].Equal(that1.Terrain[i]) { + return false + } + } + if !this.Proto2Field.Equal(that1.Proto2Field) { + return false + } + if len(this.Proto2Value) != len(that1.Proto2Value) { + return false + } + for i := range this.Proto2Value { + if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) { + return false + } + } + return true +} +func (this *Nested) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Nested) + if !ok { + return fmt.Errorf("that is not of type *Nested") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Nested but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Nestedbut is not nil && this == nil") + } + if this.Bunny != that1.Bunny { + return fmt.Errorf("Bunny this(%v) Not Equal that(%v)", this.Bunny, that1.Bunny) + } + return nil +} +func (this *Nested) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Nested) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Bunny != that1.Bunny { + return false + } + return true +} +func (this *AllMaps) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AllMaps) + if !ok { + return fmt.Errorf("that is not of type *AllMaps") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AllMaps but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AllMapsbut is not nil && this == nil") + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap)) + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i]) + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap)) + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i]) + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map)) + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i]) + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map)) + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i]) + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map)) + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i]) + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map)) + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i]) + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map)) + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i]) + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map)) + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i]) + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map)) + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i]) + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map)) + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i]) + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map)) + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i]) + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map)) + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i]) + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap)) + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i]) + } + } + if len(this.StringMap) != len(that1.StringMap) { + return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap)) + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i]) + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap)) + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i]) + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap)) + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i]) + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap)) + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i]) + } + } + return nil +} +func (this *AllMaps) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AllMaps) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) { + return false + } + for i := range this.StringToDoubleMap { + if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] { + return false + } + } + if len(this.StringToFloatMap) != len(that1.StringToFloatMap) { + return false + } + for i := range this.StringToFloatMap { + if this.StringToFloatMap[i] != that1.StringToFloatMap[i] { + return false + } + } + if len(this.Int32Map) != len(that1.Int32Map) { + return false + } + for i := range this.Int32Map { + if this.Int32Map[i] != that1.Int32Map[i] { + return false + } + } + if len(this.Int64Map) != len(that1.Int64Map) { + return false + } + for i := range this.Int64Map { + if this.Int64Map[i] != that1.Int64Map[i] { + return false + } + } + if len(this.Uint32Map) != len(that1.Uint32Map) { + return false + } + for i := range this.Uint32Map { + if this.Uint32Map[i] != that1.Uint32Map[i] { + return false + } + } + if len(this.Uint64Map) != len(that1.Uint64Map) { + return false + } + for i := range this.Uint64Map { + if this.Uint64Map[i] != that1.Uint64Map[i] { + return false + } + } + if len(this.Sint32Map) != len(that1.Sint32Map) { + return false + } + for i := range this.Sint32Map { + if this.Sint32Map[i] != that1.Sint32Map[i] { + return false + } + } + if len(this.Sint64Map) != len(that1.Sint64Map) { + return false + } + for i := range this.Sint64Map { + if this.Sint64Map[i] != that1.Sint64Map[i] { + return false + } + } + if len(this.Fixed32Map) != len(that1.Fixed32Map) { + return false + } + for i := range this.Fixed32Map { + if this.Fixed32Map[i] != that1.Fixed32Map[i] { + return false + } + } + if len(this.Sfixed32Map) != len(that1.Sfixed32Map) { + return false + } + for i := range this.Sfixed32Map { + if this.Sfixed32Map[i] != that1.Sfixed32Map[i] { + return false + } + } + if len(this.Fixed64Map) != len(that1.Fixed64Map) { + return false + } + for i := range this.Fixed64Map { + if this.Fixed64Map[i] != that1.Fixed64Map[i] { + return false + } + } + if len(this.Sfixed64Map) != len(that1.Sfixed64Map) { + return false + } + for i := range this.Sfixed64Map { + if this.Sfixed64Map[i] != that1.Sfixed64Map[i] { + return false + } + } + if len(this.BoolMap) != len(that1.BoolMap) { + return false + } + for i := range this.BoolMap { + if this.BoolMap[i] != that1.BoolMap[i] { + return false + } + } + if len(this.StringMap) != len(that1.StringMap) { + return false + } + for i := range this.StringMap { + if this.StringMap[i] != that1.StringMap[i] { + return false + } + } + if len(this.StringToBytesMap) != len(that1.StringToBytesMap) { + return false + } + for i := range this.StringToBytesMap { + if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) { + return false + } + } + if len(this.StringToEnumMap) != len(that1.StringToEnumMap) { + return false + } + for i := range this.StringToEnumMap { + if this.StringToEnumMap[i] != that1.StringToEnumMap[i] { + return false + } + } + if len(this.StringToMsgMap) != len(that1.StringToMsgMap) { + return false + } + for i := range this.StringToMsgMap { + if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) { + return false + } + } + return true +} +func (this *MessageWithMap) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*MessageWithMap) + if !ok { + return fmt.Errorf("that is not of type *MessageWithMap") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *MessageWithMap but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *MessageWithMapbut is not nil && this == nil") + } + if len(this.NameMapping) != len(that1.NameMapping) { + return fmt.Errorf("NameMapping this(%v) Not Equal that(%v)", len(this.NameMapping), len(that1.NameMapping)) + } + for i := range this.NameMapping { + if this.NameMapping[i] != that1.NameMapping[i] { + return fmt.Errorf("NameMapping this[%v](%v) Not Equal that[%v](%v)", i, this.NameMapping[i], i, that1.NameMapping[i]) + } + } + if len(this.MsgMapping) != len(that1.MsgMapping) { + return fmt.Errorf("MsgMapping this(%v) Not Equal that(%v)", len(this.MsgMapping), len(that1.MsgMapping)) + } + for i := range this.MsgMapping { + if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) { + return fmt.Errorf("MsgMapping this[%v](%v) Not Equal that[%v](%v)", i, this.MsgMapping[i], i, that1.MsgMapping[i]) + } + } + if len(this.ByteMapping) != len(that1.ByteMapping) { + return fmt.Errorf("ByteMapping this(%v) Not Equal that(%v)", len(this.ByteMapping), len(that1.ByteMapping)) + } + for i := range this.ByteMapping { + if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) { + return fmt.Errorf("ByteMapping this[%v](%v) Not Equal that[%v](%v)", i, this.ByteMapping[i], i, that1.ByteMapping[i]) + } + } + return nil +} +func (this *MessageWithMap) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*MessageWithMap) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.NameMapping) != len(that1.NameMapping) { + return false + } + for i := range this.NameMapping { + if this.NameMapping[i] != that1.NameMapping[i] { + return false + } + } + if len(this.MsgMapping) != len(that1.MsgMapping) { + return false + } + for i := range this.MsgMapping { + if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) { + return false + } + } + if len(this.ByteMapping) != len(that1.ByteMapping) { + return false + } + for i := range this.ByteMapping { + if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) { + return false + } + } + return true +} +func (this *FloatingPoint) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return fmt.Errorf("that is not of type *FloatingPoint") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *FloatingPointbut is not nil && this == nil") + } + if this.F != that1.F { + return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F) + } + return nil +} +func (this *FloatingPoint) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*FloatingPoint) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.F != that1.F { + return false + } + return true +} + +type MessageFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetName() string + GetHilarity() Message_Humour + GetHeightInCm() uint32 + GetData() []byte + GetResultCount() int64 + GetTrueScotsman() bool + GetScore() float32 + GetKey() []uint64 + GetNested() *Nested + GetTerrain() map[int64]*Nested + GetProto2Field() *test.NinOptNative + GetProto2Value() map[int64]*test.NinOptEnum +} + +func (this *Message) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Message) TestProto() github_com_gogo_protobuf_proto.Message { + return NewMessageFromFace(this) +} + +func (this *Message) GetName() string { + return this.Name +} + +func (this *Message) GetHilarity() Message_Humour { + return this.Hilarity +} + +func (this *Message) GetHeightInCm() uint32 { + return this.HeightInCm +} + +func (this *Message) GetData() []byte { + return this.Data +} + +func (this *Message) GetResultCount() int64 { + return this.ResultCount +} + +func (this *Message) GetTrueScotsman() bool { + return this.TrueScotsman +} + +func (this *Message) GetScore() float32 { + return this.Score +} + +func (this *Message) GetKey() []uint64 { + return this.Key +} + +func (this *Message) GetNested() *Nested { + return this.Nested +} + +func (this *Message) GetTerrain() map[int64]*Nested { + return this.Terrain +} + +func (this *Message) GetProto2Field() *test.NinOptNative { + return this.Proto2Field +} + +func (this *Message) GetProto2Value() map[int64]*test.NinOptEnum { + return this.Proto2Value +} + +func NewMessageFromFace(that MessageFace) *Message { + this := &Message{} + this.Name = that.GetName() + this.Hilarity = that.GetHilarity() + this.HeightInCm = that.GetHeightInCm() + this.Data = that.GetData() + this.ResultCount = that.GetResultCount() + this.TrueScotsman = that.GetTrueScotsman() + this.Score = that.GetScore() + this.Key = that.GetKey() + this.Nested = that.GetNested() + this.Terrain = that.GetTerrain() + this.Proto2Field = that.GetProto2Field() + this.Proto2Value = that.GetProto2Value() + return this +} + +type NestedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetBunny() string +} + +func (this *Nested) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Nested) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedFromFace(this) +} + +func (this *Nested) GetBunny() string { + return this.Bunny +} + +func NewNestedFromFace(that NestedFace) *Nested { + this := &Nested{} + this.Bunny = that.GetBunny() + return this +} + +type AllMapsFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetStringToDoubleMap() map[string]float64 + GetStringToFloatMap() map[string]float32 + GetInt32Map() map[int32]int32 + GetInt64Map() map[int64]int64 + GetUint32Map() map[uint32]uint32 + GetUint64Map() map[uint64]uint64 + GetSint32Map() map[int32]int32 + GetSint64Map() map[int64]int64 + GetFixed32Map() map[uint32]uint32 + GetSfixed32Map() map[int32]int32 + GetFixed64Map() map[uint64]uint64 + GetSfixed64Map() map[int64]int64 + GetBoolMap() map[bool]bool + GetStringMap() map[string]string + GetStringToBytesMap() map[string][]byte + GetStringToEnumMap() map[string]MapEnum + GetStringToMsgMap() map[string]*FloatingPoint +} + +func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAllMapsFromFace(this) +} + +func (this *AllMaps) GetStringToDoubleMap() map[string]float64 { + return this.StringToDoubleMap +} + +func (this *AllMaps) GetStringToFloatMap() map[string]float32 { + return this.StringToFloatMap +} + +func (this *AllMaps) GetInt32Map() map[int32]int32 { + return this.Int32Map +} + +func (this *AllMaps) GetInt64Map() map[int64]int64 { + return this.Int64Map +} + +func (this *AllMaps) GetUint32Map() map[uint32]uint32 { + return this.Uint32Map +} + +func (this *AllMaps) GetUint64Map() map[uint64]uint64 { + return this.Uint64Map +} + +func (this *AllMaps) GetSint32Map() map[int32]int32 { + return this.Sint32Map +} + +func (this *AllMaps) GetSint64Map() map[int64]int64 { + return this.Sint64Map +} + +func (this *AllMaps) GetFixed32Map() map[uint32]uint32 { + return this.Fixed32Map +} + +func (this *AllMaps) GetSfixed32Map() map[int32]int32 { + return this.Sfixed32Map +} + +func (this *AllMaps) GetFixed64Map() map[uint64]uint64 { + return this.Fixed64Map +} + +func (this *AllMaps) GetSfixed64Map() map[int64]int64 { + return this.Sfixed64Map +} + +func (this *AllMaps) GetBoolMap() map[bool]bool { + return this.BoolMap +} + +func (this *AllMaps) GetStringMap() map[string]string { + return this.StringMap +} + +func (this *AllMaps) GetStringToBytesMap() map[string][]byte { + return this.StringToBytesMap +} + +func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum { + return this.StringToEnumMap +} + +func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint { + return this.StringToMsgMap +} + +func NewAllMapsFromFace(that AllMapsFace) *AllMaps { + this := &AllMaps{} + this.StringToDoubleMap = that.GetStringToDoubleMap() + this.StringToFloatMap = that.GetStringToFloatMap() + this.Int32Map = that.GetInt32Map() + this.Int64Map = that.GetInt64Map() + this.Uint32Map = that.GetUint32Map() + this.Uint64Map = that.GetUint64Map() + this.Sint32Map = that.GetSint32Map() + this.Sint64Map = that.GetSint64Map() + this.Fixed32Map = that.GetFixed32Map() + this.Sfixed32Map = that.GetSfixed32Map() + this.Fixed64Map = that.GetFixed64Map() + this.Sfixed64Map = that.GetSfixed64Map() + this.BoolMap = that.GetBoolMap() + this.StringMap = that.GetStringMap() + this.StringToBytesMap = that.GetStringToBytesMap() + this.StringToEnumMap = that.GetStringToEnumMap() + this.StringToMsgMap = that.GetStringToMsgMap() + return this +} + +type MessageWithMapFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNameMapping() map[int32]string + GetMsgMapping() map[int64]*FloatingPoint + GetByteMapping() map[bool][]byte +} + +func (this *MessageWithMap) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *MessageWithMap) TestProto() github_com_gogo_protobuf_proto.Message { + return NewMessageWithMapFromFace(this) +} + +func (this *MessageWithMap) GetNameMapping() map[int32]string { + return this.NameMapping +} + +func (this *MessageWithMap) GetMsgMapping() map[int64]*FloatingPoint { + return this.MsgMapping +} + +func (this *MessageWithMap) GetByteMapping() map[bool][]byte { + return this.ByteMapping +} + +func NewMessageWithMapFromFace(that MessageWithMapFace) *MessageWithMap { + this := &MessageWithMap{} + this.NameMapping = that.GetNameMapping() + this.MsgMapping = that.GetMsgMapping() + this.ByteMapping = that.GetByteMapping() + return this +} + +type FloatingPointFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetF() float64 +} + +func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message { + return NewFloatingPointFromFace(this) +} + +func (this *FloatingPoint) GetF() float64 { + return this.F +} + +func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint { + this := &FloatingPoint{} + this.F = that.GetF() + return this +} + +func (this *Message) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 16) + s = append(s, "&theproto3.Message{") + s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n") + s = append(s, "Hilarity: "+fmt.Sprintf("%#v", this.Hilarity)+",\n") + s = append(s, "HeightInCm: "+fmt.Sprintf("%#v", this.HeightInCm)+",\n") + s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") + s = append(s, "ResultCount: "+fmt.Sprintf("%#v", this.ResultCount)+",\n") + s = append(s, "TrueScotsman: "+fmt.Sprintf("%#v", this.TrueScotsman)+",\n") + s = append(s, "Score: "+fmt.Sprintf("%#v", this.Score)+",\n") + s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n") + if this.Nested != nil { + s = append(s, "Nested: "+fmt.Sprintf("%#v", this.Nested)+",\n") + } + keysForTerrain := make([]int64, 0, len(this.Terrain)) + for k := range this.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + mapStringForTerrain := "map[int64]*Nested{" + for _, k := range keysForTerrain { + mapStringForTerrain += fmt.Sprintf("%#v: %#v,", k, this.Terrain[k]) + } + mapStringForTerrain += "}" + if this.Terrain != nil { + s = append(s, "Terrain: "+mapStringForTerrain+",\n") + } + if this.Proto2Field != nil { + s = append(s, "Proto2Field: "+fmt.Sprintf("%#v", this.Proto2Field)+",\n") + } + keysForProto2Value := make([]int64, 0, len(this.Proto2Value)) + for k := range this.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + mapStringForProto2Value := "map[int64]*test.NinOptEnum{" + for _, k := range keysForProto2Value { + mapStringForProto2Value += fmt.Sprintf("%#v: %#v,", k, this.Proto2Value[k]) + } + mapStringForProto2Value += "}" + if this.Proto2Value != nil { + s = append(s, "Proto2Value: "+mapStringForProto2Value+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Nested) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&theproto3.Nested{") + s = append(s, "Bunny: "+fmt.Sprintf("%#v", this.Bunny)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AllMaps) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 21) + s = append(s, "&theproto3.AllMaps{") + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + if this.StringToDoubleMap != nil { + s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n") + } + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + if this.StringToFloatMap != nil { + s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n") + } + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + if this.Int32Map != nil { + s = append(s, "Int32Map: "+mapStringForInt32Map+",\n") + } + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + if this.Int64Map != nil { + s = append(s, "Int64Map: "+mapStringForInt64Map+",\n") + } + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + if this.Uint32Map != nil { + s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n") + } + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + if this.Uint64Map != nil { + s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n") + } + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + if this.Sint32Map != nil { + s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n") + } + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + if this.Sint64Map != nil { + s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n") + } + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + if this.Fixed32Map != nil { + s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n") + } + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + if this.Sfixed32Map != nil { + s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n") + } + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + if this.Fixed64Map != nil { + s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n") + } + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + if this.Sfixed64Map != nil { + s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n") + } + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + if this.BoolMap != nil { + s = append(s, "BoolMap: "+mapStringForBoolMap+",\n") + } + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + if this.StringMap != nil { + s = append(s, "StringMap: "+mapStringForStringMap+",\n") + } + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + if this.StringToBytesMap != nil { + s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n") + } + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + if this.StringToEnumMap != nil { + s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n") + } + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + if this.StringToMsgMap != nil { + s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MessageWithMap) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&theproto3.MessageWithMap{") + keysForNameMapping := make([]int32, 0, len(this.NameMapping)) + for k := range this.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + mapStringForNameMapping := "map[int32]string{" + for _, k := range keysForNameMapping { + mapStringForNameMapping += fmt.Sprintf("%#v: %#v,", k, this.NameMapping[k]) + } + mapStringForNameMapping += "}" + if this.NameMapping != nil { + s = append(s, "NameMapping: "+mapStringForNameMapping+",\n") + } + keysForMsgMapping := make([]int64, 0, len(this.MsgMapping)) + for k := range this.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + mapStringForMsgMapping := "map[int64]*FloatingPoint{" + for _, k := range keysForMsgMapping { + mapStringForMsgMapping += fmt.Sprintf("%#v: %#v,", k, this.MsgMapping[k]) + } + mapStringForMsgMapping += "}" + if this.MsgMapping != nil { + s = append(s, "MsgMapping: "+mapStringForMsgMapping+",\n") + } + keysForByteMapping := make([]bool, 0, len(this.ByteMapping)) + for k := range this.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + mapStringForByteMapping := "map[bool][]byte{" + for _, k := range keysForByteMapping { + mapStringForByteMapping += fmt.Sprintf("%#v: %#v,", k, this.ByteMapping[k]) + } + mapStringForByteMapping += "}" + if this.ByteMapping != nil { + s = append(s, "ByteMapping: "+mapStringForByteMapping+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *FloatingPoint) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&theproto3.FloatingPoint{") + s = append(s, "F: "+fmt.Sprintf("%#v", this.F)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringTheproto3(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringTheproto3(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedMessage(r randyTheproto3, easy bool) *Message { + this := &Message{} + this.Name = randStringTheproto3(r) + this.Hilarity = Message_Humour([]int32{0, 1, 2, 3}[r.Intn(4)]) + this.HeightInCm = uint32(r.Uint32()) + v1 := r.Intn(100) + this.Data = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Data[i] = byte(r.Intn(256)) + } + this.ResultCount = int64(r.Int63()) + if r.Intn(2) == 0 { + this.ResultCount *= -1 + } + this.TrueScotsman = bool(bool(r.Intn(2) == 0)) + this.Score = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Score *= -1 + } + v2 := r.Intn(100) + this.Key = make([]uint64, v2) + for i := 0; i < v2; i++ { + this.Key[i] = uint64(uint64(r.Uint32())) + } + if r.Intn(10) != 0 { + this.Nested = NewPopulatedNested(r, easy) + } + if r.Intn(10) != 0 { + v3 := r.Intn(10) + this.Terrain = make(map[int64]*Nested) + for i := 0; i < v3; i++ { + this.Terrain[int64(r.Int63())] = NewPopulatedNested(r, easy) + } + } + if r.Intn(10) != 0 { + this.Proto2Field = test.NewPopulatedNinOptNative(r, easy) + } + if r.Intn(10) != 0 { + v4 := r.Intn(10) + this.Proto2Value = make(map[int64]*test.NinOptEnum) + for i := 0; i < v4; i++ { + this.Proto2Value[int64(r.Int63())] = test.NewPopulatedNinOptEnum(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedNested(r randyTheproto3, easy bool) *Nested { + this := &Nested{} + this.Bunny = randStringTheproto3(r) + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedAllMaps(r randyTheproto3, easy bool) *AllMaps { + this := &AllMaps{} + if r.Intn(10) != 0 { + v5 := r.Intn(10) + this.StringToDoubleMap = make(map[string]float64) + for i := 0; i < v5; i++ { + v6 := randStringTheproto3(r) + this.StringToDoubleMap[v6] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.StringToDoubleMap[v6] *= -1 + } + } + } + if r.Intn(10) != 0 { + v7 := r.Intn(10) + this.StringToFloatMap = make(map[string]float32) + for i := 0; i < v7; i++ { + v8 := randStringTheproto3(r) + this.StringToFloatMap[v8] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.StringToFloatMap[v8] *= -1 + } + } + } + if r.Intn(10) != 0 { + v9 := r.Intn(10) + this.Int32Map = make(map[int32]int32) + for i := 0; i < v9; i++ { + v10 := int32(r.Int31()) + this.Int32Map[v10] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Int32Map[v10] *= -1 + } + } + } + if r.Intn(10) != 0 { + v11 := r.Intn(10) + this.Int64Map = make(map[int64]int64) + for i := 0; i < v11; i++ { + v12 := int64(r.Int63()) + this.Int64Map[v12] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Int64Map[v12] *= -1 + } + } + } + if r.Intn(10) != 0 { + v13 := r.Intn(10) + this.Uint32Map = make(map[uint32]uint32) + for i := 0; i < v13; i++ { + v14 := uint32(r.Uint32()) + this.Uint32Map[v14] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v15 := r.Intn(10) + this.Uint64Map = make(map[uint64]uint64) + for i := 0; i < v15; i++ { + v16 := uint64(uint64(r.Uint32())) + this.Uint64Map[v16] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v17 := r.Intn(10) + this.Sint32Map = make(map[int32]int32) + for i := 0; i < v17; i++ { + v18 := int32(r.Int31()) + this.Sint32Map[v18] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sint32Map[v18] *= -1 + } + } + } + if r.Intn(10) != 0 { + v19 := r.Intn(10) + this.Sint64Map = make(map[int64]int64) + for i := 0; i < v19; i++ { + v20 := int64(r.Int63()) + this.Sint64Map[v20] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sint64Map[v20] *= -1 + } + } + } + if r.Intn(10) != 0 { + v21 := r.Intn(10) + this.Fixed32Map = make(map[uint32]uint32) + for i := 0; i < v21; i++ { + v22 := uint32(r.Uint32()) + this.Fixed32Map[v22] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v23 := r.Intn(10) + this.Sfixed32Map = make(map[int32]int32) + for i := 0; i < v23; i++ { + v24 := int32(r.Int31()) + this.Sfixed32Map[v24] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sfixed32Map[v24] *= -1 + } + } + } + if r.Intn(10) != 0 { + v25 := r.Intn(10) + this.Fixed64Map = make(map[uint64]uint64) + for i := 0; i < v25; i++ { + v26 := uint64(uint64(r.Uint32())) + this.Fixed64Map[v26] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v27 := r.Intn(10) + this.Sfixed64Map = make(map[int64]int64) + for i := 0; i < v27; i++ { + v28 := int64(r.Int63()) + this.Sfixed64Map[v28] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sfixed64Map[v28] *= -1 + } + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(10) + this.BoolMap = make(map[bool]bool) + for i := 0; i < v29; i++ { + v30 := bool(bool(r.Intn(2) == 0)) + this.BoolMap[v30] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v31 := r.Intn(10) + this.StringMap = make(map[string]string) + for i := 0; i < v31; i++ { + this.StringMap[randStringTheproto3(r)] = randStringTheproto3(r) + } + } + if r.Intn(10) != 0 { + v32 := r.Intn(10) + this.StringToBytesMap = make(map[string][]byte) + for i := 0; i < v32; i++ { + v33 := r.Intn(100) + v34 := randStringTheproto3(r) + this.StringToBytesMap[v34] = make([]byte, v33) + for i := 0; i < v33; i++ { + this.StringToBytesMap[v34][i] = byte(r.Intn(256)) + } + } + } + if r.Intn(10) != 0 { + v35 := r.Intn(10) + this.StringToEnumMap = make(map[string]MapEnum) + for i := 0; i < v35; i++ { + this.StringToEnumMap[randStringTheproto3(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if r.Intn(10) != 0 { + v36 := r.Intn(10) + this.StringToMsgMap = make(map[string]*FloatingPoint) + for i := 0; i < v36; i++ { + this.StringToMsgMap[randStringTheproto3(r)] = NewPopulatedFloatingPoint(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedMessageWithMap(r randyTheproto3, easy bool) *MessageWithMap { + this := &MessageWithMap{} + if r.Intn(10) != 0 { + v37 := r.Intn(10) + this.NameMapping = make(map[int32]string) + for i := 0; i < v37; i++ { + this.NameMapping[int32(r.Int31())] = randStringTheproto3(r) + } + } + if r.Intn(10) != 0 { + v38 := r.Intn(10) + this.MsgMapping = make(map[int64]*FloatingPoint) + for i := 0; i < v38; i++ { + this.MsgMapping[int64(r.Int63())] = NewPopulatedFloatingPoint(r, easy) + } + } + if r.Intn(10) != 0 { + v39 := r.Intn(10) + this.ByteMapping = make(map[bool][]byte) + for i := 0; i < v39; i++ { + v40 := r.Intn(100) + v41 := bool(bool(r.Intn(2) == 0)) + this.ByteMapping[v41] = make([]byte, v40) + for i := 0; i < v40; i++ { + this.ByteMapping[v41][i] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedFloatingPoint(r randyTheproto3, easy bool) *FloatingPoint { + this := &FloatingPoint{} + this.F = float64(r.Float64()) + if r.Intn(2) == 0 { + this.F *= -1 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +type randyTheproto3 interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneTheproto3(r randyTheproto3) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringTheproto3(r randyTheproto3) string { + v42 := r.Intn(100) + tmps := make([]rune, v42) + for i := 0; i < v42; i++ { + tmps[i] = randUTF8RuneTheproto3(r) + } + return string(tmps) +} +func randUnrecognizedTheproto3(r randyTheproto3, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldTheproto3(data, r, fieldNumber, wire) + } + return data +} +func randFieldTheproto3(data []byte, r randyTheproto3, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + v43 := r.Int63() + if r.Intn(2) == 0 { + v43 *= -1 + } + data = encodeVarintPopulateTheproto3(data, uint64(v43)) + case 1: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateTheproto3(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateTheproto3(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateTheproto3(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *Message) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + if m.Hilarity != 0 { + n += 1 + sovTheproto3(uint64(m.Hilarity)) + } + if m.HeightInCm != 0 { + n += 1 + sovTheproto3(uint64(m.HeightInCm)) + } + if m.Data != nil { + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + } + if m.ResultCount != 0 { + n += 1 + sovTheproto3(uint64(m.ResultCount)) + } + if m.TrueScotsman { + n += 2 + } + if m.Score != 0 { + n += 5 + } + if len(m.Key) > 0 { + for _, e := range m.Key { + n += 1 + sovTheproto3(uint64(e)) + } + } + if m.Nested != nil { + l = m.Nested.Size() + n += 1 + l + sovTheproto3(uint64(l)) + } + if len(m.Terrain) > 0 { + for k, v := range m.Terrain { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if m.Proto2Field != nil { + l = m.Proto2Field.Size() + n += 1 + l + sovTheproto3(uint64(l)) + } + if len(m.Proto2Value) > 0 { + for k, v := range m.Proto2Value { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *Nested) Size() (n int) { + var l int + _ = l + l = len(m.Bunny) + if l > 0 { + n += 1 + l + sovTheproto3(uint64(l)) + } + return n +} + +func (m *AllMaps) Size() (n int) { + var l int + _ = l + if len(m.StringToDoubleMap) > 0 { + for k, v := range m.StringToDoubleMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToFloatMap) > 0 { + for k, v := range m.StringToFloatMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Int32Map) > 0 { + for k, v := range m.Int32Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Int64Map) > 0 { + for k, v := range m.Int64Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Uint32Map) > 0 { + for k, v := range m.Uint32Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Uint64Map) > 0 { + for k, v := range m.Uint64Map { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sint32Map) > 0 { + for k, v := range m.Sint32Map { + _ = k + _ = v + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sint64Map) > 0 { + for k, v := range m.Sint64Map { + _ = k + _ = v + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Fixed32Map) > 0 { + for k, v := range m.Fixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sfixed32Map) > 0 { + for k, v := range m.Sfixed32Map { + _ = k + _ = v + mapEntrySize := 1 + 4 + 1 + 4 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Fixed64Map) > 0 { + for k, v := range m.Fixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.Sfixed64Map) > 0 { + for k, v := range m.Sfixed64Map { + _ = k + _ = v + mapEntrySize := 1 + 8 + 1 + 8 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.BoolMap) > 0 { + for k, v := range m.BoolMap { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + 1 + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringMap) > 0 { + for k, v := range m.StringMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToBytesMap) > 0 { + for k, v := range m.StringToBytesMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToEnumMap) > 0 { + for k, v := range m.StringToEnumMap { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v)) + n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.StringToMsgMap) > 0 { + for k, v := range m.StringToMsgMap { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *MessageWithMap) Size() (n int) { + var l int + _ = l + if len(m.NameMapping) > 0 { + for k, v := range m.NameMapping { + _ = k + _ = v + mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.MsgMapping) > 0 { + for k, v := range m.MsgMapping { + _ = k + _ = v + l = 0 + if v != nil { + l = v.Size() + } + mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + l + sovTheproto3(uint64(l)) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + if len(m.ByteMapping) > 0 { + for k, v := range m.ByteMapping { + _ = k + _ = v + mapEntrySize := 1 + 1 + 1 + len(v) + sovTheproto3(uint64(len(v))) + n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize)) + } + } + return n +} + +func (m *FloatingPoint) Size() (n int) { + var l int + _ = l + if m.F != 0 { + n += 9 + } + return n +} + +func sovTheproto3(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozTheproto3(x uint64) (n int) { + return sovTheproto3(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Message) String() string { + if this == nil { + return "nil" + } + keysForTerrain := make([]int64, 0, len(this.Terrain)) + for k := range this.Terrain { + keysForTerrain = append(keysForTerrain, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain) + mapStringForTerrain := "map[int64]*Nested{" + for _, k := range keysForTerrain { + mapStringForTerrain += fmt.Sprintf("%v: %v,", k, this.Terrain[k]) + } + mapStringForTerrain += "}" + keysForProto2Value := make([]int64, 0, len(this.Proto2Value)) + for k := range this.Proto2Value { + keysForProto2Value = append(keysForProto2Value, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value) + mapStringForProto2Value := "map[int64]*test.NinOptEnum{" + for _, k := range keysForProto2Value { + mapStringForProto2Value += fmt.Sprintf("%v: %v,", k, this.Proto2Value[k]) + } + mapStringForProto2Value += "}" + s := strings.Join([]string{`&Message{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Hilarity:` + fmt.Sprintf("%v", this.Hilarity) + `,`, + `HeightInCm:` + fmt.Sprintf("%v", this.HeightInCm) + `,`, + `Data:` + fmt.Sprintf("%v", this.Data) + `,`, + `ResultCount:` + fmt.Sprintf("%v", this.ResultCount) + `,`, + `TrueScotsman:` + fmt.Sprintf("%v", this.TrueScotsman) + `,`, + `Score:` + fmt.Sprintf("%v", this.Score) + `,`, + `Key:` + fmt.Sprintf("%v", this.Key) + `,`, + `Nested:` + strings.Replace(fmt.Sprintf("%v", this.Nested), "Nested", "Nested", 1) + `,`, + `Terrain:` + mapStringForTerrain + `,`, + `Proto2Field:` + strings.Replace(fmt.Sprintf("%v", this.Proto2Field), "NinOptNative", "test.NinOptNative", 1) + `,`, + `Proto2Value:` + mapStringForProto2Value + `,`, + `}`, + }, "") + return s +} +func (this *Nested) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Nested{`, + `Bunny:` + fmt.Sprintf("%v", this.Bunny) + `,`, + `}`, + }, "") + return s +} +func (this *AllMaps) String() string { + if this == nil { + return "nil" + } + keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap)) + for k := range this.StringToDoubleMap { + keysForStringToDoubleMap = append(keysForStringToDoubleMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap) + mapStringForStringToDoubleMap := "map[string]float64{" + for _, k := range keysForStringToDoubleMap { + mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k]) + } + mapStringForStringToDoubleMap += "}" + keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap)) + for k := range this.StringToFloatMap { + keysForStringToFloatMap = append(keysForStringToFloatMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap) + mapStringForStringToFloatMap := "map[string]float32{" + for _, k := range keysForStringToFloatMap { + mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k]) + } + mapStringForStringToFloatMap += "}" + keysForInt32Map := make([]int32, 0, len(this.Int32Map)) + for k := range this.Int32Map { + keysForInt32Map = append(keysForInt32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map) + mapStringForInt32Map := "map[int32]int32{" + for _, k := range keysForInt32Map { + mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k]) + } + mapStringForInt32Map += "}" + keysForInt64Map := make([]int64, 0, len(this.Int64Map)) + for k := range this.Int64Map { + keysForInt64Map = append(keysForInt64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map) + mapStringForInt64Map := "map[int64]int64{" + for _, k := range keysForInt64Map { + mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k]) + } + mapStringForInt64Map += "}" + keysForUint32Map := make([]uint32, 0, len(this.Uint32Map)) + for k := range this.Uint32Map { + keysForUint32Map = append(keysForUint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map) + mapStringForUint32Map := "map[uint32]uint32{" + for _, k := range keysForUint32Map { + mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k]) + } + mapStringForUint32Map += "}" + keysForUint64Map := make([]uint64, 0, len(this.Uint64Map)) + for k := range this.Uint64Map { + keysForUint64Map = append(keysForUint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map) + mapStringForUint64Map := "map[uint64]uint64{" + for _, k := range keysForUint64Map { + mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k]) + } + mapStringForUint64Map += "}" + keysForSint32Map := make([]int32, 0, len(this.Sint32Map)) + for k := range this.Sint32Map { + keysForSint32Map = append(keysForSint32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map) + mapStringForSint32Map := "map[int32]int32{" + for _, k := range keysForSint32Map { + mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k]) + } + mapStringForSint32Map += "}" + keysForSint64Map := make([]int64, 0, len(this.Sint64Map)) + for k := range this.Sint64Map { + keysForSint64Map = append(keysForSint64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map) + mapStringForSint64Map := "map[int64]int64{" + for _, k := range keysForSint64Map { + mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k]) + } + mapStringForSint64Map += "}" + keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map)) + for k := range this.Fixed32Map { + keysForFixed32Map = append(keysForFixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map) + mapStringForFixed32Map := "map[uint32]uint32{" + for _, k := range keysForFixed32Map { + mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k]) + } + mapStringForFixed32Map += "}" + keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map)) + for k := range this.Sfixed32Map { + keysForSfixed32Map = append(keysForSfixed32Map, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map) + mapStringForSfixed32Map := "map[int32]int32{" + for _, k := range keysForSfixed32Map { + mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k]) + } + mapStringForSfixed32Map += "}" + keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map)) + for k := range this.Fixed64Map { + keysForFixed64Map = append(keysForFixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map) + mapStringForFixed64Map := "map[uint64]uint64{" + for _, k := range keysForFixed64Map { + mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k]) + } + mapStringForFixed64Map += "}" + keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map)) + for k := range this.Sfixed64Map { + keysForSfixed64Map = append(keysForSfixed64Map, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map) + mapStringForSfixed64Map := "map[int64]int64{" + for _, k := range keysForSfixed64Map { + mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k]) + } + mapStringForSfixed64Map += "}" + keysForBoolMap := make([]bool, 0, len(this.BoolMap)) + for k := range this.BoolMap { + keysForBoolMap = append(keysForBoolMap, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap) + mapStringForBoolMap := "map[bool]bool{" + for _, k := range keysForBoolMap { + mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k]) + } + mapStringForBoolMap += "}" + keysForStringMap := make([]string, 0, len(this.StringMap)) + for k := range this.StringMap { + keysForStringMap = append(keysForStringMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap) + mapStringForStringMap := "map[string]string{" + for _, k := range keysForStringMap { + mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k]) + } + mapStringForStringMap += "}" + keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap)) + for k := range this.StringToBytesMap { + keysForStringToBytesMap = append(keysForStringToBytesMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap) + mapStringForStringToBytesMap := "map[string][]byte{" + for _, k := range keysForStringToBytesMap { + mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k]) + } + mapStringForStringToBytesMap += "}" + keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap)) + for k := range this.StringToEnumMap { + keysForStringToEnumMap = append(keysForStringToEnumMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap) + mapStringForStringToEnumMap := "map[string]MapEnum{" + for _, k := range keysForStringToEnumMap { + mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k]) + } + mapStringForStringToEnumMap += "}" + keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap)) + for k := range this.StringToMsgMap { + keysForStringToMsgMap = append(keysForStringToMsgMap, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap) + mapStringForStringToMsgMap := "map[string]*FloatingPoint{" + for _, k := range keysForStringToMsgMap { + mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k]) + } + mapStringForStringToMsgMap += "}" + s := strings.Join([]string{`&AllMaps{`, + `StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`, + `StringToFloatMap:` + mapStringForStringToFloatMap + `,`, + `Int32Map:` + mapStringForInt32Map + `,`, + `Int64Map:` + mapStringForInt64Map + `,`, + `Uint32Map:` + mapStringForUint32Map + `,`, + `Uint64Map:` + mapStringForUint64Map + `,`, + `Sint32Map:` + mapStringForSint32Map + `,`, + `Sint64Map:` + mapStringForSint64Map + `,`, + `Fixed32Map:` + mapStringForFixed32Map + `,`, + `Sfixed32Map:` + mapStringForSfixed32Map + `,`, + `Fixed64Map:` + mapStringForFixed64Map + `,`, + `Sfixed64Map:` + mapStringForSfixed64Map + `,`, + `BoolMap:` + mapStringForBoolMap + `,`, + `StringMap:` + mapStringForStringMap + `,`, + `StringToBytesMap:` + mapStringForStringToBytesMap + `,`, + `StringToEnumMap:` + mapStringForStringToEnumMap + `,`, + `StringToMsgMap:` + mapStringForStringToMsgMap + `,`, + `}`, + }, "") + return s +} +func (this *MessageWithMap) String() string { + if this == nil { + return "nil" + } + keysForNameMapping := make([]int32, 0, len(this.NameMapping)) + for k := range this.NameMapping { + keysForNameMapping = append(keysForNameMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping) + mapStringForNameMapping := "map[int32]string{" + for _, k := range keysForNameMapping { + mapStringForNameMapping += fmt.Sprintf("%v: %v,", k, this.NameMapping[k]) + } + mapStringForNameMapping += "}" + keysForMsgMapping := make([]int64, 0, len(this.MsgMapping)) + for k := range this.MsgMapping { + keysForMsgMapping = append(keysForMsgMapping, k) + } + github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping) + mapStringForMsgMapping := "map[int64]*FloatingPoint{" + for _, k := range keysForMsgMapping { + mapStringForMsgMapping += fmt.Sprintf("%v: %v,", k, this.MsgMapping[k]) + } + mapStringForMsgMapping += "}" + keysForByteMapping := make([]bool, 0, len(this.ByteMapping)) + for k := range this.ByteMapping { + keysForByteMapping = append(keysForByteMapping, k) + } + github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping) + mapStringForByteMapping := "map[bool][]byte{" + for _, k := range keysForByteMapping { + mapStringForByteMapping += fmt.Sprintf("%v: %v,", k, this.ByteMapping[k]) + } + mapStringForByteMapping += "}" + s := strings.Join([]string{`&MessageWithMap{`, + `NameMapping:` + mapStringForNameMapping + `,`, + `MsgMapping:` + mapStringForMsgMapping + `,`, + `ByteMapping:` + mapStringForByteMapping + `,`, + `}`, + }, "") + return s +} +func (this *FloatingPoint) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&FloatingPoint{`, + `F:` + fmt.Sprintf("%v", this.F) + `,`, + `}`, + }, "") + return s +} +func valueToStringTheproto3(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Message) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Message: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Message: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Hilarity", wireType) + } + m.Hilarity = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Hilarity |= (Message_Humour(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field HeightInCm", wireType) + } + m.HeightInCm = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.HeightInCm |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append([]byte{}, data[iNdEx:postIndex]...) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ResultCount", wireType) + } + m.ResultCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.ResultCount |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TrueScotsman", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.TrueScotsman = bool(v != 0) + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Score", wireType) + } + if iNdEx+4 > l { + return io.ErrUnexpectedEOF + } + m.Score = *(*float32)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 4 + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Key = append(m.Key, v) + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Nested", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Nested == nil { + m.Nested = &Nested{} + } + if err := m.Nested.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Terrain", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &Nested{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.Terrain == nil { + m.Terrain = make(map[int64]*Nested) + } + m.Terrain[mapkey] = mapvalue + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proto2Field", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Proto2Field == nil { + m.Proto2Field = &test.NinOptNative{} + } + if err := m.Proto2Field.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proto2Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &test.NinOptEnum{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.Proto2Value == nil { + m.Proto2Value = make(map[int64]*test.NinOptEnum) + } + m.Proto2Value[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTheproto3Unsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Nested) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Nested: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Nested: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Bunny", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Bunny = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTheproto3Unsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AllMaps) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AllMaps: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AllMaps: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvaluetemp = uint64(data[iNdEx-8]) + mapvaluetemp |= uint64(data[iNdEx-7]) << 8 + mapvaluetemp |= uint64(data[iNdEx-6]) << 16 + mapvaluetemp |= uint64(data[iNdEx-5]) << 24 + mapvaluetemp |= uint64(data[iNdEx-4]) << 32 + mapvaluetemp |= uint64(data[iNdEx-3]) << 40 + mapvaluetemp |= uint64(data[iNdEx-2]) << 48 + mapvaluetemp |= uint64(data[iNdEx-1]) << 56 + mapvalue := math.Float64frombits(mapvaluetemp) + if m.StringToDoubleMap == nil { + m.StringToDoubleMap = make(map[string]float64) + } + m.StringToDoubleMap[mapkey] = mapvalue + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvaluetemp = uint32(data[iNdEx-4]) + mapvaluetemp |= uint32(data[iNdEx-3]) << 8 + mapvaluetemp |= uint32(data[iNdEx-2]) << 16 + mapvaluetemp |= uint32(data[iNdEx-1]) << 24 + mapvalue := math.Float32frombits(mapvaluetemp) + if m.StringToFloatMap == nil { + m.StringToFloatMap = make(map[string]float32) + } + m.StringToFloatMap[mapkey] = mapvalue + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Int32Map == nil { + m.Int32Map = make(map[int32]int32) + } + m.Int32Map[mapkey] = mapvalue + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Int64Map == nil { + m.Int64Map = make(map[int64]int64) + } + m.Int64Map[mapkey] = mapvalue + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Uint32Map == nil { + m.Uint32Map = make(map[uint32]uint32) + } + m.Uint32Map[mapkey] = mapvalue + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.Uint64Map == nil { + m.Uint64Map = make(map[uint64]uint64) + } + m.Uint64Map[mapkey] = mapvalue + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31)) + mapkey := int32(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31)) + mapvalue := int32(mapvaluetemp) + if m.Sint32Map == nil { + m.Sint32Map = make(map[int32]int32) + } + m.Sint32Map[mapkey] = mapvalue + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63) + mapkey := int64(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63) + mapvalue := int64(mapvaluetemp) + if m.Sint64Map == nil { + m.Sint64Map = make(map[int64]int64) + } + m.Sint64Map[mapkey] = mapvalue + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapkey = uint32(data[iNdEx-4]) + mapkey |= uint32(data[iNdEx-3]) << 8 + mapkey |= uint32(data[iNdEx-2]) << 16 + mapkey |= uint32(data[iNdEx-1]) << 24 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvalue = uint32(data[iNdEx-4]) + mapvalue |= uint32(data[iNdEx-3]) << 8 + mapvalue |= uint32(data[iNdEx-2]) << 16 + mapvalue |= uint32(data[iNdEx-1]) << 24 + if m.Fixed32Map == nil { + m.Fixed32Map = make(map[uint32]uint32) + } + m.Fixed32Map[mapkey] = mapvalue + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapkey = int32(data[iNdEx-4]) + mapkey |= int32(data[iNdEx-3]) << 8 + mapkey |= int32(data[iNdEx-2]) << 16 + mapkey |= int32(data[iNdEx-1]) << 24 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + mapvalue = int32(data[iNdEx-4]) + mapvalue |= int32(data[iNdEx-3]) << 8 + mapvalue |= int32(data[iNdEx-2]) << 16 + mapvalue |= int32(data[iNdEx-1]) << 24 + if m.Sfixed32Map == nil { + m.Sfixed32Map = make(map[int32]int32) + } + m.Sfixed32Map[mapkey] = mapvalue + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapkey = uint64(data[iNdEx-8]) + mapkey |= uint64(data[iNdEx-7]) << 8 + mapkey |= uint64(data[iNdEx-6]) << 16 + mapkey |= uint64(data[iNdEx-5]) << 24 + mapkey |= uint64(data[iNdEx-4]) << 32 + mapkey |= uint64(data[iNdEx-3]) << 40 + mapkey |= uint64(data[iNdEx-2]) << 48 + mapkey |= uint64(data[iNdEx-1]) << 56 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvalue = uint64(data[iNdEx-8]) + mapvalue |= uint64(data[iNdEx-7]) << 8 + mapvalue |= uint64(data[iNdEx-6]) << 16 + mapvalue |= uint64(data[iNdEx-5]) << 24 + mapvalue |= uint64(data[iNdEx-4]) << 32 + mapvalue |= uint64(data[iNdEx-3]) << 40 + mapvalue |= uint64(data[iNdEx-2]) << 48 + mapvalue |= uint64(data[iNdEx-1]) << 56 + if m.Fixed64Map == nil { + m.Fixed64Map = make(map[uint64]uint64) + } + m.Fixed64Map[mapkey] = mapvalue + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapkey = int64(data[iNdEx-8]) + mapkey |= int64(data[iNdEx-7]) << 8 + mapkey |= int64(data[iNdEx-6]) << 16 + mapkey |= int64(data[iNdEx-5]) << 24 + mapkey |= int64(data[iNdEx-4]) << 32 + mapkey |= int64(data[iNdEx-3]) << 40 + mapkey |= int64(data[iNdEx-2]) << 48 + mapkey |= int64(data[iNdEx-1]) << 56 + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue int64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + mapvalue = int64(data[iNdEx-8]) + mapvalue |= int64(data[iNdEx-7]) << 8 + mapvalue |= int64(data[iNdEx-6]) << 16 + mapvalue |= int64(data[iNdEx-5]) << 24 + mapvalue |= int64(data[iNdEx-4]) << 32 + mapvalue |= int64(data[iNdEx-3]) << 40 + mapvalue |= int64(data[iNdEx-2]) << 48 + mapvalue |= int64(data[iNdEx-1]) << 56 + if m.Sfixed64Map == nil { + m.Sfixed64Map = make(map[int64]int64) + } + m.Sfixed64Map[mapkey] = mapvalue + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkey := bool(mapkeytemp != 0) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvaluetemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvaluetemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapvalue := bool(mapvaluetemp != 0) + if m.BoolMap == nil { + m.BoolMap = make(map[bool]bool) + } + m.BoolMap[mapkey] = mapvalue + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue := string(data[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + if m.StringMap == nil { + m.StringMap = make(map[string]string) + } + m.StringMap[mapkey] = mapvalue + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapbyteLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := make([]byte, mapbyteLen) + copy(mapvalue, data[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + if m.StringToBytesMap == nil { + m.StringToBytesMap = make(map[string][]byte) + } + m.StringToBytesMap[mapkey] = mapvalue + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapvalue MapEnum + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapvalue |= (MapEnum(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if m.StringToEnumMap == nil { + m.StringToEnumMap = make(map[string]MapEnum) + } + m.StringToEnumMap[mapkey] = mapvalue + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(data[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &FloatingPoint{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.StringToMsgMap == nil { + m.StringToMsgMap = make(map[string]*FloatingPoint) + } + m.StringToMsgMap[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTheproto3Unsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MessageWithMap) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MessageWithMap: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MessageWithMap: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NameMapping", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkey int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkey |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLenmapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue := string(data[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + if m.NameMapping == nil { + m.NameMapping = make(map[int32]string) + } + m.NameMapping[mapkey] = mapvalue + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MsgMapping", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63) + mapkey := int64(mapkeytemp) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapmsglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapmsglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postmsgIndex := iNdEx + mapmsglen + if mapmsglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if postmsgIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := &FloatingPoint{} + if err := mapvalue.Unmarshal(data[iNdEx:postmsgIndex]); err != nil { + return err + } + iNdEx = postmsgIndex + if m.MsgMapping == nil { + m.MsgMapping = make(map[int64]*FloatingPoint) + } + m.MsgMapping[mapkey] = mapvalue + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ByteMapping", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapkeytemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapkeytemp |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + mapkey := bool(mapkeytemp != 0) + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var mapbyteLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + mapbyteLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intMapbyteLen := int(mapbyteLen) + if intMapbyteLen < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + postbytesIndex := iNdEx + intMapbyteLen + if postbytesIndex > l { + return io.ErrUnexpectedEOF + } + mapvalue := make([]byte, mapbyteLen) + copy(mapvalue, data[iNdEx:postbytesIndex]) + iNdEx = postbytesIndex + if m.ByteMapping == nil { + m.ByteMapping = make(map[bool][]byte) + } + m.ByteMapping[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTheproto3Unsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FloatingPoint) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FloatingPoint: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FloatingPoint: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field F", wireType) + } + if iNdEx+8 > l { + return io.ErrUnexpectedEOF + } + m.F = *(*float64)(unsafe.Pointer(&data[iNdEx])) + iNdEx += 8 + default: + iNdEx = preIndex + skippy, err := skipTheproto3Unsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTheproto3Unsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTheproto3Unsafe(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthTheproto3Unsafe + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTheproto3Unsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipTheproto3Unsafe(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthTheproto3Unsafe = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTheproto3Unsafe = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeunmarshaler/theproto3.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeunmarshaler/theproto3.proto new file mode 100644 index 0000000000000000000000000000000000000000..65d257e91d3bd16356bf0daffe7f279b487b1888 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeunmarshaler/theproto3.proto @@ -0,0 +1,129 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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 theproto3; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +import "github.com/gogo/protobuf/test/combos/both/thetest.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = true; + +message Message { + enum Humour { + UNKNOWN = 0; + PUNS = 1; + SLAPSTICK = 2; + BILL_BAILEY = 3; + } + + string name = 1; + Humour hilarity = 2; + uint32 height_in_cm = 3; + bytes data = 4; + int64 result_count = 7; + bool true_scotsman = 8; + float score = 9; + + repeated uint64 key = 5; + Nested nested = 6; + + map terrain = 10; + test.NinOptNative proto2_field = 11; + map proto2_value = 13; +} + +message Nested { + string bunny = 1; +} + +enum MapEnum { + MA = 0; + MB = 1; + MC = 2; +} + +message AllMaps { + map StringToDoubleMap = 1; + map StringToFloatMap = 2; + map Int32Map = 3; + map Int64Map = 4; + map Uint32Map = 5; + map Uint64Map = 6; + map Sint32Map = 7; + map Sint64Map = 8; + map Fixed32Map = 9; + map Sfixed32Map = 10; + map Fixed64Map = 11; + map Sfixed64Map = 12; + map BoolMap = 13; + map StringMap = 14; + map StringToBytesMap = 15; + map StringToEnumMap = 16; + map StringToMsgMap = 17; +} + +message MessageWithMap { + map name_mapping = 1; + map msg_mapping = 2; + map byte_mapping = 3; +} + +message FloatingPoint { + double f = 1; +} \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeunmarshaler/theproto3pb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeunmarshaler/theproto3pb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..e2951e3d8b8a980ea3870d74c78284f24623b364 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/combos/unsafeunmarshaler/theproto3pb_test.go @@ -0,0 +1,1092 @@ +// Code generated by protoc-gen-gogo. +// source: combos/unsafeunmarshaler/theproto3.proto +// DO NOT EDIT! + +/* +Package theproto3 is a generated protocol buffer package. + +It is generated from these files: + combos/unsafeunmarshaler/theproto3.proto + +It has these top-level messages: + Message + Nested + AllMaps + MessageWithMap + FloatingPoint +*/ +package theproto3 + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" +// discarding unused import test "github.com/gogo/protobuf/test/combos/both" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestMessageProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkMessageProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Message, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMessageProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessage(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Message{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNestedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nested, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNested(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNested(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Nested{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAllMapsProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAllMapsProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAllMaps(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AllMaps{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageWithMapProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkMessageWithMapProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MessageWithMap, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMessageWithMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMessageWithMapProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMessageWithMap(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &MessageWithMap{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkFloatingPointProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkFloatingPointProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedFloatingPoint(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &FloatingPoint{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Message{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nested{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAllMapsJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AllMaps{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMessageWithMapJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MessageWithMap{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestFloatingPointJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &FloatingPoint{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMessageProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Message{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Message{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAllMapsProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageWithMapProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMessageWithMapProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestFloatingPointProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTheproto3Description(t *testing.T) { + Theproto3Description() +} +func TestMessageVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Message{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Nested{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAllMapsVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AllMaps{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMessageWithMapVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &MessageWithMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestFloatingPointVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &FloatingPoint{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMessageFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAllMapsFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestMessageWithMapFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestFloatingPointFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestMessageGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAllMapsGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMessageWithMapGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestFloatingPointGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMessageSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessage(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMessageSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Message, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNested(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nested, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNested(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAllMapsSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAllMaps(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAllMapsSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AllMaps, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAllMaps(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageWithMapSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMessageWithMap(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMessageWithMapSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MessageWithMap, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMessageWithMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestFloatingPointSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedFloatingPoint(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkFloatingPointSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*FloatingPoint, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedFloatingPoint(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMessageStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessage(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNested(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAllMapsStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAllMaps(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestMessageWithMapStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMessageWithMap(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestFloatingPointStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedFloatingPoint(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/doc.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/doc.go new file mode 100644 index 0000000000000000000000000000000000000000..e559a27ba34599545400174f8ffb13e6abc2b939 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/doc.go @@ -0,0 +1 @@ +package theproto3 diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/footer.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/footer.proto new file mode 100644 index 0000000000000000000000000000000000000000..53f5cd5cb441b5eb7e0dee3a8ad3bf8f0b550886 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/footer.proto @@ -0,0 +1,10 @@ + +message MessageWithMap { + map name_mapping = 1; + map msg_mapping = 2; + map byte_mapping = 3; +} + +message FloatingPoint { + double f = 1; +} \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/header.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/header.proto new file mode 100644 index 0000000000000000000000000000000000000000..b5435da1b7e477b442f9f12105cbc2c2787031b6 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/header.proto @@ -0,0 +1,93 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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 theproto3; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +import "github.com/gogo/protobuf/test/combos/both/thetest.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Message { + enum Humour { + UNKNOWN = 0; + PUNS = 1; + SLAPSTICK = 2; + BILL_BAILEY = 3; + } + + string name = 1; + Humour hilarity = 2; + uint32 height_in_cm = 3; + bytes data = 4; + int64 result_count = 7; + bool true_scotsman = 8; + float score = 9; + + repeated uint64 key = 5; + Nested nested = 6; + + map terrain = 10; + test.NinOptNative proto2_field = 11; + map proto2_value = 13; +} + +message Nested { + string bunny = 1; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/maps.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/maps.proto new file mode 100644 index 0000000000000000000000000000000000000000..be9df05dd9842bf10e28c20be27481c3bbe4a6c0 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/maps.proto @@ -0,0 +1,26 @@ + +enum MapEnum { + MA = 0; + MB = 1; + MC = 2; +} + +message AllMaps { + map StringToDoubleMap = 1; + map StringToFloatMap = 2; + map Int32Map = 3; + map Int64Map = 4; + map Uint32Map = 5; + map Uint64Map = 6; + map Sint32Map = 7; + map Sint64Map = 8; + map Fixed32Map = 9; + map Sfixed32Map = 10; + map Fixed64Map = 11; + map Sfixed64Map = 12; + map BoolMap = 13; + map StringMap = 14; + map StringToBytesMap = 15; + map StringToEnumMap = 16; + map StringToMsgMap = 17; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/theproto3.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/theproto3.proto new file mode 100644 index 0000000000000000000000000000000000000000..8ceec9aad5558f3301207a22efa1879f926dd0d6 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/theproto3/theproto3.proto @@ -0,0 +1,129 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2014 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 theproto3; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +import "github.com/gogo/protobuf/test/combos/both/thetest.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message Message { + enum Humour { + UNKNOWN = 0; + PUNS = 1; + SLAPSTICK = 2; + BILL_BAILEY = 3; + } + + string name = 1; + Humour hilarity = 2; + uint32 height_in_cm = 3; + bytes data = 4; + int64 result_count = 7; + bool true_scotsman = 8; + float score = 9; + + repeated uint64 key = 5; + Nested nested = 6; + + map terrain = 10; + test.NinOptNative proto2_field = 11; + map proto2_value = 13; +} + +message Nested { + string bunny = 1; +} + +enum MapEnum { + MA = 0; + MB = 1; + MC = 2; +} + +message AllMaps { + map StringToDoubleMap = 1; + map StringToFloatMap = 2; + map Int32Map = 3; + map Int64Map = 4; + map Uint32Map = 5; + map Uint64Map = 6; + map Sint32Map = 7; + map Sint64Map = 8; + map Fixed32Map = 9; + map Sfixed32Map = 10; + map Fixed64Map = 11; + map Sfixed64Map = 12; + map BoolMap = 13; + map StringMap = 14; + map StringToBytesMap = 15; + map StringToEnumMap = 16; + map StringToMsgMap = 17; +} + +message MessageWithMap { + map name_mapping = 1; + map msg_mapping = 2; + map byte_mapping = 3; +} + +message FloatingPoint { + double f = 1; +} \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/thetest.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/thetest.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..cd2ffb951971d0cb20778efc1f0d3c138f22d951 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/thetest.pb.go @@ -0,0 +1,21902 @@ +// Code generated by protoc-gen-gogo. +// source: thetest.proto +// DO NOT EDIT! + +/* + Package test is a generated protocol buffer package. + + It is generated from these files: + thetest.proto + + It has these top-level messages: + NidOptNative + NinOptNative + NidRepNative + NinRepNative + NidRepPackedNative + NinRepPackedNative + NidOptStruct + NinOptStruct + NidRepStruct + NinRepStruct + NidEmbeddedStruct + NinEmbeddedStruct + NidNestedStruct + NinNestedStruct + NidOptCustom + CustomDash + NinOptCustom + NidRepCustom + NinRepCustom + NinOptNativeUnion + NinOptStructUnion + NinEmbeddedStructUnion + NinNestedStructUnion + Tree + OrBranch + AndBranch + Leaf + DeepTree + ADeepBranch + AndDeepBranch + DeepLeaf + Nil + NidOptEnum + NinOptEnum + NidRepEnum + NinRepEnum + NinOptEnumDefault + AnotherNinOptEnum + AnotherNinOptEnumDefault + Timer + MyExtendable + OtherExtenable + NestedDefinition + NestedScope + NinOptNativeDefault + CustomContainer + CustomNameNidOptNative + CustomNameNinOptNative + CustomNameNinRepNative + CustomNameNinStruct + CustomNameCustomType + CustomNameNinEmbeddedStructUnion + CustomNameEnum + NoExtensionsMap + Unrecognized + UnrecognizedWithInner + UnrecognizedWithEmbed +*/ +package test + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import github_com_gogo_protobuf_test_custom "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom" +import github_com_gogo_protobuf_test_custom_dash_type "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/custom-dash-type" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import strconv "strconv" + +import bytes "bytes" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import strings "strings" +import sort "sort" +import reflect "reflect" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type TheTestEnum int32 + +const ( + A TheTestEnum = 0 + B TheTestEnum = 1 + C TheTestEnum = 2 +) + +var TheTestEnum_name = map[int32]string{ + 0: "A", + 1: "B", + 2: "C", +} +var TheTestEnum_value = map[string]int32{ + "A": 0, + "B": 1, + "C": 2, +} + +func (x TheTestEnum) Enum() *TheTestEnum { + p := new(TheTestEnum) + *p = x + return p +} +func (x TheTestEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(TheTestEnum_name, int32(x)) +} +func (x *TheTestEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(TheTestEnum_value, data, "TheTestEnum") + if err != nil { + return err + } + *x = TheTestEnum(value) + return nil +} + +type AnotherTestEnum int32 + +const ( + D AnotherTestEnum = 10 + E AnotherTestEnum = 11 +) + +var AnotherTestEnum_name = map[int32]string{ + 10: "D", + 11: "E", +} +var AnotherTestEnum_value = map[string]int32{ + "D": 10, + "E": 11, +} + +func (x AnotherTestEnum) Enum() *AnotherTestEnum { + p := new(AnotherTestEnum) + *p = x + return p +} +func (x AnotherTestEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(AnotherTestEnum_name, int32(x)) +} +func (x *AnotherTestEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(AnotherTestEnum_value, data, "AnotherTestEnum") + if err != nil { + return err + } + *x = AnotherTestEnum(value) + return nil +} + +type NestedDefinition_NestedEnum int32 + +const ( + TYPE_NESTED NestedDefinition_NestedEnum = 1 +) + +var NestedDefinition_NestedEnum_name = map[int32]string{ + 1: "TYPE_NESTED", +} +var NestedDefinition_NestedEnum_value = map[string]int32{ + "TYPE_NESTED": 1, +} + +func (x NestedDefinition_NestedEnum) Enum() *NestedDefinition_NestedEnum { + p := new(NestedDefinition_NestedEnum) + *p = x + return p +} +func (x NestedDefinition_NestedEnum) MarshalJSON() ([]byte, error) { + return proto.MarshalJSONEnum(NestedDefinition_NestedEnum_name, int32(x)) +} +func (x *NestedDefinition_NestedEnum) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(NestedDefinition_NestedEnum_value, data, "NestedDefinition_NestedEnum") + if err != nil { + return err + } + *x = NestedDefinition_NestedEnum(value) + return nil +} + +type NidOptNative struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + Field3 int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3"` + Field4 int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4"` + Field5 uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5"` + Field6 uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + Field8 int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8"` + Field9 uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9"` + Field10 int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10"` + Field11 uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11"` + Field12 int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12"` + Field13 bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + Field14 string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptNative) Reset() { *m = NidOptNative{} } +func (*NidOptNative) ProtoMessage() {} + +type NinOptNative struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"` + Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"` + Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"` + Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"` + Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNative) Reset() { *m = NinOptNative{} } +func (*NinOptNative) ProtoMessage() {} + +type NidRepNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepNative) Reset() { *m = NidRepNative{} } +func (*NidRepNative) ProtoMessage() {} + +type NinRepNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepNative) Reset() { *m = NinRepNative{} } +func (*NinRepNative) ProtoMessage() {} + +type NidRepPackedNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepPackedNative) Reset() { *m = NidRepPackedNative{} } +func (*NidRepPackedNative) ProtoMessage() {} + +type NinRepPackedNative struct { + Field1 []float64 `protobuf:"fixed64,1,rep,packed,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,packed,name=Field2" json:"Field2,omitempty"` + Field3 []int32 `protobuf:"varint,3,rep,packed,name=Field3" json:"Field3,omitempty"` + Field4 []int64 `protobuf:"varint,4,rep,packed,name=Field4" json:"Field4,omitempty"` + Field5 []uint32 `protobuf:"varint,5,rep,packed,name=Field5" json:"Field5,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,packed,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,packed,name=Field7" json:"Field7,omitempty"` + Field8 []int64 `protobuf:"zigzag64,8,rep,packed,name=Field8" json:"Field8,omitempty"` + Field9 []uint32 `protobuf:"fixed32,9,rep,packed,name=Field9" json:"Field9,omitempty"` + Field10 []int32 `protobuf:"fixed32,10,rep,packed,name=Field10" json:"Field10,omitempty"` + Field11 []uint64 `protobuf:"fixed64,11,rep,packed,name=Field11" json:"Field11,omitempty"` + Field12 []int64 `protobuf:"fixed64,12,rep,packed,name=Field12" json:"Field12,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,packed,name=Field13" json:"Field13,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepPackedNative) Reset() { *m = NinRepPackedNative{} } +func (*NinRepPackedNative) ProtoMessage() {} + +type NidOptStruct struct { + Field1 float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + Field2 float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + Field3 NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3"` + Field4 NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4"` + Field6 uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + Field7 int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + Field8 NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8"` + Field13 bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + Field14 string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptStruct) Reset() { *m = NidOptStruct{} } +func (*NidOptStruct) ProtoMessage() {} + +type NinOptStruct struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field8 *NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptStruct) Reset() { *m = NinOptStruct{} } +func (*NinOptStruct) ProtoMessage() {} + +type NidRepStruct struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []NidOptNative `protobuf:"bytes,3,rep,name=Field3" json:"Field3"` + Field4 []NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []NidOptNative `protobuf:"bytes,8,rep,name=Field8" json:"Field8"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepStruct) Reset() { *m = NidRepStruct{} } +func (*NidRepStruct) ProtoMessage() {} + +type NinRepStruct struct { + Field1 []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + Field2 []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 []*NidOptNative `protobuf:"bytes,3,rep,name=Field3" json:"Field3,omitempty"` + Field4 []*NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4,omitempty"` + Field6 []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + Field7 []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + Field8 []*NidOptNative `protobuf:"bytes,8,rep,name=Field8" json:"Field8,omitempty"` + Field13 []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + Field14 []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + Field15 [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepStruct) Reset() { *m = NinRepStruct{} } +func (*NinRepStruct) ProtoMessage() {} + +type NidEmbeddedStruct struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 NidOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200"` + Field210 bool `protobuf:"varint,210,opt,name=Field210" json:"Field210"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidEmbeddedStruct) Reset() { *m = NidEmbeddedStruct{} } +func (*NidEmbeddedStruct) ProtoMessage() {} + +type NinEmbeddedStruct struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 *NidOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + Field210 *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinEmbeddedStruct) Reset() { *m = NinEmbeddedStruct{} } +func (*NinEmbeddedStruct) ProtoMessage() {} + +type NidNestedStruct struct { + Field1 NidOptStruct `protobuf:"bytes,1,opt,name=Field1" json:"Field1"` + Field2 []NidRepStruct `protobuf:"bytes,2,rep,name=Field2" json:"Field2"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidNestedStruct) Reset() { *m = NidNestedStruct{} } +func (*NidNestedStruct) ProtoMessage() {} + +type NinNestedStruct struct { + Field1 *NinOptStruct `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 []*NinRepStruct `protobuf:"bytes,2,rep,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinNestedStruct) Reset() { *m = NinNestedStruct{} } +func (*NinNestedStruct) ProtoMessage() {} + +type NidOptCustom struct { + Id Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id"` + Value github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptCustom) Reset() { *m = NidOptCustom{} } +func (*NidOptCustom) ProtoMessage() {} + +type CustomDash struct { + Value *github_com_gogo_protobuf_test_custom_dash_type.Bytes `protobuf:"bytes,1,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom-dash-type.Bytes" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomDash) Reset() { *m = CustomDash{} } +func (*CustomDash) ProtoMessage() {} + +type NinOptCustom struct { + Id *Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id,omitempty"` + Value *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptCustom) Reset() { *m = NinOptCustom{} } +func (*NinOptCustom) ProtoMessage() {} + +type NidRepCustom struct { + Id []Uuid `protobuf:"bytes,1,rep,name=Id,customtype=Uuid" json:"Id"` + Value []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepCustom) Reset() { *m = NidRepCustom{} } +func (*NidRepCustom) ProtoMessage() {} + +type NinRepCustom struct { + Id []Uuid `protobuf:"bytes,1,rep,name=Id,customtype=Uuid" json:"Id,omitempty"` + Value []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,rep,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepCustom) Reset() { *m = NinRepCustom{} } +func (*NinRepCustom) ProtoMessage() {} + +type NinOptNativeUnion struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNativeUnion) Reset() { *m = NinOptNativeUnion{} } +func (*NinOptNativeUnion) ProtoMessage() {} + +type NinOptStructUnion struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *NinOptNative `protobuf:"bytes,4,opt,name=Field4" json:"Field4,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptStructUnion) Reset() { *m = NinOptStructUnion{} } +func (*NinOptStructUnion) ProtoMessage() {} + +type NinEmbeddedStructUnion struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + Field200 *NinOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + Field210 *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinEmbeddedStructUnion) Reset() { *m = NinEmbeddedStructUnion{} } +func (*NinEmbeddedStructUnion) ProtoMessage() {} + +type NinNestedStructUnion struct { + Field1 *NinOptNativeUnion `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *NinOptStructUnion `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *NinEmbeddedStructUnion `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinNestedStructUnion) Reset() { *m = NinNestedStructUnion{} } +func (*NinNestedStructUnion) ProtoMessage() {} + +type Tree struct { + Or *OrBranch `protobuf:"bytes,1,opt,name=Or" json:"Or,omitempty"` + And *AndBranch `protobuf:"bytes,2,opt,name=And" json:"And,omitempty"` + Leaf *Leaf `protobuf:"bytes,3,opt,name=Leaf" json:"Leaf,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Tree) Reset() { *m = Tree{} } +func (*Tree) ProtoMessage() {} + +type OrBranch struct { + Left Tree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right Tree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OrBranch) Reset() { *m = OrBranch{} } +func (*OrBranch) ProtoMessage() {} + +type AndBranch struct { + Left Tree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right Tree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AndBranch) Reset() { *m = AndBranch{} } +func (*AndBranch) ProtoMessage() {} + +type Leaf struct { + Value int64 `protobuf:"varint,1,opt,name=Value" json:"Value"` + StrValue string `protobuf:"bytes,2,opt,name=StrValue" json:"StrValue"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Leaf) Reset() { *m = Leaf{} } +func (*Leaf) ProtoMessage() {} + +type DeepTree struct { + Down *ADeepBranch `protobuf:"bytes,1,opt,name=Down" json:"Down,omitempty"` + And *AndDeepBranch `protobuf:"bytes,2,opt,name=And" json:"And,omitempty"` + Leaf *DeepLeaf `protobuf:"bytes,3,opt,name=Leaf" json:"Leaf,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeepTree) Reset() { *m = DeepTree{} } +func (*DeepTree) ProtoMessage() {} + +type ADeepBranch struct { + Down DeepTree `protobuf:"bytes,2,opt,name=Down" json:"Down"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ADeepBranch) Reset() { *m = ADeepBranch{} } +func (*ADeepBranch) ProtoMessage() {} + +type AndDeepBranch struct { + Left DeepTree `protobuf:"bytes,1,opt,name=Left" json:"Left"` + Right DeepTree `protobuf:"bytes,2,opt,name=Right" json:"Right"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AndDeepBranch) Reset() { *m = AndDeepBranch{} } +func (*AndDeepBranch) ProtoMessage() {} + +type DeepLeaf struct { + Tree Tree `protobuf:"bytes,1,opt,name=Tree" json:"Tree"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeepLeaf) Reset() { *m = DeepLeaf{} } +func (*DeepLeaf) ProtoMessage() {} + +type Nil struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *Nil) Reset() { *m = Nil{} } +func (*Nil) ProtoMessage() {} + +type NidOptEnum struct { + Field1 TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidOptEnum) Reset() { *m = NidOptEnum{} } +func (*NidOptEnum) ProtoMessage() {} + +type NinOptEnum struct { + Field1 *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptEnum) Reset() { *m = NinOptEnum{} } +func (*NinOptEnum) ProtoMessage() {} + +type NidRepEnum struct { + Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NidRepEnum) Reset() { *m = NidRepEnum{} } +func (*NidRepEnum) ProtoMessage() {} + +type NinRepEnum struct { + Field1 []TheTestEnum `protobuf:"varint,1,rep,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinRepEnum) Reset() { *m = NinRepEnum{} } +func (*NinRepEnum) ProtoMessage() {} + +type NinOptEnumDefault struct { + Field1 *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum,def=2" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptEnumDefault) Reset() { *m = NinOptEnumDefault{} } +func (*NinOptEnumDefault) ProtoMessage() {} + +const Default_NinOptEnumDefault_Field1 TheTestEnum = C + +func (m *NinOptEnumDefault) GetField1() TheTestEnum { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_NinOptEnumDefault_Field1 +} + +type AnotherNinOptEnum struct { + Field1 *AnotherTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.AnotherTestEnum" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AnotherNinOptEnum) Reset() { *m = AnotherNinOptEnum{} } +func (*AnotherNinOptEnum) ProtoMessage() {} + +type AnotherNinOptEnumDefault struct { + Field1 *AnotherTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.AnotherTestEnum,def=11" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AnotherNinOptEnumDefault) Reset() { *m = AnotherNinOptEnumDefault{} } +func (*AnotherNinOptEnumDefault) ProtoMessage() {} + +const Default_AnotherNinOptEnumDefault_Field1 AnotherTestEnum = E + +func (m *AnotherNinOptEnumDefault) GetField1() AnotherTestEnum { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_AnotherNinOptEnumDefault_Field1 +} + +type Timer struct { + Time1 int64 `protobuf:"fixed64,1,opt,name=Time1" json:"Time1"` + Time2 int64 `protobuf:"fixed64,2,opt,name=Time2" json:"Time2"` + Data []byte `protobuf:"bytes,3,opt,name=Data" json:"Data"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Timer) Reset() { *m = Timer{} } +func (*Timer) ProtoMessage() {} + +type MyExtendable struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MyExtendable) Reset() { *m = MyExtendable{} } +func (*MyExtendable) ProtoMessage() {} + +var extRange_MyExtendable = []proto.ExtensionRange{ + {100, 199}, +} + +func (*MyExtendable) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MyExtendable +} +func (m *MyExtendable) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type OtherExtenable struct { + Field2 *int64 `protobuf:"varint,2,opt,name=Field2" json:"Field2,omitempty"` + Field13 *int64 `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + M *MyExtendable `protobuf:"bytes,1,opt,name=M" json:"M,omitempty"` + XXX_extensions map[int32]proto.Extension `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OtherExtenable) Reset() { *m = OtherExtenable{} } +func (*OtherExtenable) ProtoMessage() {} + +var extRange_OtherExtenable = []proto.ExtensionRange{ + {14, 16}, + {10, 12}, +} + +func (*OtherExtenable) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_OtherExtenable +} +func (m *OtherExtenable) ExtensionMap() map[int32]proto.Extension { + if m.XXX_extensions == nil { + m.XXX_extensions = make(map[int32]proto.Extension) + } + return m.XXX_extensions +} + +type NestedDefinition struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + EnumField *NestedDefinition_NestedEnum `protobuf:"varint,2,opt,name=EnumField,enum=test.NestedDefinition_NestedEnum" json:"EnumField,omitempty"` + NNM *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,3,opt,name=NNM" json:"NNM,omitempty"` + NM *NestedDefinition_NestedMessage `protobuf:"bytes,4,opt,name=NM" json:"NM,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition) Reset() { *m = NestedDefinition{} } +func (*NestedDefinition) ProtoMessage() {} + +type NestedDefinition_NestedMessage struct { + NestedField1 *uint64 `protobuf:"fixed64,1,opt,name=NestedField1" json:"NestedField1,omitempty"` + NNM *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,2,opt,name=NNM" json:"NNM,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition_NestedMessage) Reset() { *m = NestedDefinition_NestedMessage{} } +func (*NestedDefinition_NestedMessage) ProtoMessage() {} + +type NestedDefinition_NestedMessage_NestedNestedMsg struct { + NestedNestedField1 *string `protobuf:"bytes,10,opt,name=NestedNestedField1" json:"NestedNestedField1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Reset() { + *m = NestedDefinition_NestedMessage_NestedNestedMsg{} +} +func (*NestedDefinition_NestedMessage_NestedNestedMsg) ProtoMessage() {} + +type NestedScope struct { + A *NestedDefinition_NestedMessage_NestedNestedMsg `protobuf:"bytes,1,opt,name=A" json:"A,omitempty"` + B *NestedDefinition_NestedEnum `protobuf:"varint,2,opt,name=B,enum=test.NestedDefinition_NestedEnum" json:"B,omitempty"` + C *NestedDefinition_NestedMessage `protobuf:"bytes,3,opt,name=C" json:"C,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedScope) Reset() { *m = NestedScope{} } +func (*NestedScope) ProtoMessage() {} + +type NinOptNativeDefault struct { + Field1 *float64 `protobuf:"fixed64,1,opt,name=Field1,def=1234.1234" json:"Field1,omitempty"` + Field2 *float32 `protobuf:"fixed32,2,opt,name=Field2,def=1234.1234" json:"Field2,omitempty"` + Field3 *int32 `protobuf:"varint,3,opt,name=Field3,def=1234" json:"Field3,omitempty"` + Field4 *int64 `protobuf:"varint,4,opt,name=Field4,def=1234" json:"Field4,omitempty"` + Field5 *uint32 `protobuf:"varint,5,opt,name=Field5,def=1234" json:"Field5,omitempty"` + Field6 *uint64 `protobuf:"varint,6,opt,name=Field6,def=1234" json:"Field6,omitempty"` + Field7 *int32 `protobuf:"zigzag32,7,opt,name=Field7,def=1234" json:"Field7,omitempty"` + Field8 *int64 `protobuf:"zigzag64,8,opt,name=Field8,def=1234" json:"Field8,omitempty"` + Field9 *uint32 `protobuf:"fixed32,9,opt,name=Field9,def=1234" json:"Field9,omitempty"` + Field10 *int32 `protobuf:"fixed32,10,opt,name=Field10,def=1234" json:"Field10,omitempty"` + Field11 *uint64 `protobuf:"fixed64,11,opt,name=Field11,def=1234" json:"Field11,omitempty"` + Field12 *int64 `protobuf:"fixed64,12,opt,name=Field12,def=1234" json:"Field12,omitempty"` + Field13 *bool `protobuf:"varint,13,opt,name=Field13,def=1" json:"Field13,omitempty"` + Field14 *string `protobuf:"bytes,14,opt,name=Field14,def=1234" json:"Field14,omitempty"` + Field15 []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NinOptNativeDefault) Reset() { *m = NinOptNativeDefault{} } +func (*NinOptNativeDefault) ProtoMessage() {} + +const Default_NinOptNativeDefault_Field1 float64 = 1234.1234 +const Default_NinOptNativeDefault_Field2 float32 = 1234.1234 +const Default_NinOptNativeDefault_Field3 int32 = 1234 +const Default_NinOptNativeDefault_Field4 int64 = 1234 +const Default_NinOptNativeDefault_Field5 uint32 = 1234 +const Default_NinOptNativeDefault_Field6 uint64 = 1234 +const Default_NinOptNativeDefault_Field7 int32 = 1234 +const Default_NinOptNativeDefault_Field8 int64 = 1234 +const Default_NinOptNativeDefault_Field9 uint32 = 1234 +const Default_NinOptNativeDefault_Field10 int32 = 1234 +const Default_NinOptNativeDefault_Field11 uint64 = 1234 +const Default_NinOptNativeDefault_Field12 int64 = 1234 +const Default_NinOptNativeDefault_Field13 bool = true +const Default_NinOptNativeDefault_Field14 string = "1234" + +func (m *NinOptNativeDefault) GetField1() float64 { + if m != nil && m.Field1 != nil { + return *m.Field1 + } + return Default_NinOptNativeDefault_Field1 +} + +func (m *NinOptNativeDefault) GetField2() float32 { + if m != nil && m.Field2 != nil { + return *m.Field2 + } + return Default_NinOptNativeDefault_Field2 +} + +func (m *NinOptNativeDefault) GetField3() int32 { + if m != nil && m.Field3 != nil { + return *m.Field3 + } + return Default_NinOptNativeDefault_Field3 +} + +func (m *NinOptNativeDefault) GetField4() int64 { + if m != nil && m.Field4 != nil { + return *m.Field4 + } + return Default_NinOptNativeDefault_Field4 +} + +func (m *NinOptNativeDefault) GetField5() uint32 { + if m != nil && m.Field5 != nil { + return *m.Field5 + } + return Default_NinOptNativeDefault_Field5 +} + +func (m *NinOptNativeDefault) GetField6() uint64 { + if m != nil && m.Field6 != nil { + return *m.Field6 + } + return Default_NinOptNativeDefault_Field6 +} + +func (m *NinOptNativeDefault) GetField7() int32 { + if m != nil && m.Field7 != nil { + return *m.Field7 + } + return Default_NinOptNativeDefault_Field7 +} + +func (m *NinOptNativeDefault) GetField8() int64 { + if m != nil && m.Field8 != nil { + return *m.Field8 + } + return Default_NinOptNativeDefault_Field8 +} + +func (m *NinOptNativeDefault) GetField9() uint32 { + if m != nil && m.Field9 != nil { + return *m.Field9 + } + return Default_NinOptNativeDefault_Field9 +} + +func (m *NinOptNativeDefault) GetField10() int32 { + if m != nil && m.Field10 != nil { + return *m.Field10 + } + return Default_NinOptNativeDefault_Field10 +} + +func (m *NinOptNativeDefault) GetField11() uint64 { + if m != nil && m.Field11 != nil { + return *m.Field11 + } + return Default_NinOptNativeDefault_Field11 +} + +func (m *NinOptNativeDefault) GetField12() int64 { + if m != nil && m.Field12 != nil { + return *m.Field12 + } + return Default_NinOptNativeDefault_Field12 +} + +func (m *NinOptNativeDefault) GetField13() bool { + if m != nil && m.Field13 != nil { + return *m.Field13 + } + return Default_NinOptNativeDefault_Field13 +} + +func (m *NinOptNativeDefault) GetField14() string { + if m != nil && m.Field14 != nil { + return *m.Field14 + } + return Default_NinOptNativeDefault_Field14 +} + +func (m *NinOptNativeDefault) GetField15() []byte { + if m != nil { + return m.Field15 + } + return nil +} + +type CustomContainer struct { + CustomStruct NidOptCustom `protobuf:"bytes,1,opt,name=CustomStruct" json:"CustomStruct"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomContainer) Reset() { *m = CustomContainer{} } +func (*CustomContainer) ProtoMessage() {} + +type CustomNameNidOptNative struct { + FieldA float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1"` + FieldB float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2"` + FieldC int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3"` + FieldD int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4"` + FieldE uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5"` + FieldF uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6"` + FieldG int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7"` + FieldH int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8"` + FieldI uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9"` + FieldJ int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10"` + FieldK uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11"` + FieldL int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12"` + FieldM bool `protobuf:"varint,13,opt,name=Field13" json:"Field13"` + FieldN string `protobuf:"bytes,14,opt,name=Field14" json:"Field14"` + FieldO []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNidOptNative) Reset() { *m = CustomNameNidOptNative{} } +func (*CustomNameNidOptNative) ProtoMessage() {} + +type CustomNameNinOptNative struct { + FieldA *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + FieldB *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + FieldC *int32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` + FieldD *int64 `protobuf:"varint,4,opt,name=Field4" json:"Field4,omitempty"` + FieldE *uint32 `protobuf:"varint,5,opt,name=Field5" json:"Field5,omitempty"` + FieldF *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + FieldG *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + FieldH *int64 `protobuf:"zigzag64,8,opt,name=Field8" json:"Field8,omitempty"` + FieldI *uint32 `protobuf:"fixed32,9,opt,name=Field9" json:"Field9,omitempty"` + FieldJ *int32 `protobuf:"fixed32,10,opt,name=Field10" json:"Field10,omitempty"` + FieldK *uint64 `protobuf:"fixed64,11,opt,name=Field11" json:"Field11,omitempty"` + FielL *int64 `protobuf:"fixed64,12,opt,name=Field12" json:"Field12,omitempty"` + FieldM *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + FieldN *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + FieldO []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinOptNative) Reset() { *m = CustomNameNinOptNative{} } +func (*CustomNameNinOptNative) ProtoMessage() {} + +type CustomNameNinRepNative struct { + FieldA []float64 `protobuf:"fixed64,1,rep,name=Field1" json:"Field1,omitempty"` + FieldB []float32 `protobuf:"fixed32,2,rep,name=Field2" json:"Field2,omitempty"` + FieldC []int32 `protobuf:"varint,3,rep,name=Field3" json:"Field3,omitempty"` + FieldD []int64 `protobuf:"varint,4,rep,name=Field4" json:"Field4,omitempty"` + FieldE []uint32 `protobuf:"varint,5,rep,name=Field5" json:"Field5,omitempty"` + FieldF []uint64 `protobuf:"varint,6,rep,name=Field6" json:"Field6,omitempty"` + FieldG []int32 `protobuf:"zigzag32,7,rep,name=Field7" json:"Field7,omitempty"` + FieldH []int64 `protobuf:"zigzag64,8,rep,name=Field8" json:"Field8,omitempty"` + FieldI []uint32 `protobuf:"fixed32,9,rep,name=Field9" json:"Field9,omitempty"` + FieldJ []int32 `protobuf:"fixed32,10,rep,name=Field10" json:"Field10,omitempty"` + FieldK []uint64 `protobuf:"fixed64,11,rep,name=Field11" json:"Field11,omitempty"` + FieldL []int64 `protobuf:"fixed64,12,rep,name=Field12" json:"Field12,omitempty"` + FieldM []bool `protobuf:"varint,13,rep,name=Field13" json:"Field13,omitempty"` + FieldN []string `protobuf:"bytes,14,rep,name=Field14" json:"Field14,omitempty"` + FieldO [][]byte `protobuf:"bytes,15,rep,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinRepNative) Reset() { *m = CustomNameNinRepNative{} } +func (*CustomNameNinRepNative) ProtoMessage() {} + +type CustomNameNinStruct struct { + FieldA *float64 `protobuf:"fixed64,1,opt,name=Field1" json:"Field1,omitempty"` + FieldB *float32 `protobuf:"fixed32,2,opt,name=Field2" json:"Field2,omitempty"` + FieldC *NidOptNative `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + FieldD []*NinOptNative `protobuf:"bytes,4,rep,name=Field4" json:"Field4,omitempty"` + FieldE *uint64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + FieldF *int32 `protobuf:"zigzag32,7,opt,name=Field7" json:"Field7,omitempty"` + FieldG *NidOptNative `protobuf:"bytes,8,opt,name=Field8" json:"Field8,omitempty"` + FieldH *bool `protobuf:"varint,13,opt,name=Field13" json:"Field13,omitempty"` + FieldI *string `protobuf:"bytes,14,opt,name=Field14" json:"Field14,omitempty"` + FieldJ []byte `protobuf:"bytes,15,opt,name=Field15" json:"Field15,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinStruct) Reset() { *m = CustomNameNinStruct{} } +func (*CustomNameNinStruct) ProtoMessage() {} + +type CustomNameCustomType struct { + FieldA *Uuid `protobuf:"bytes,1,opt,name=Id,customtype=Uuid" json:"Id,omitempty"` + FieldB *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=Value,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Value,omitempty"` + FieldC []Uuid `protobuf:"bytes,3,rep,name=Ids,customtype=Uuid" json:"Ids,omitempty"` + FieldD []github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,4,rep,name=Values,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"Values,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameCustomType) Reset() { *m = CustomNameCustomType{} } +func (*CustomNameCustomType) ProtoMessage() {} + +type CustomNameNinEmbeddedStructUnion struct { + *NidOptNative `protobuf:"bytes,1,opt,name=Field1,embedded=Field1" json:"Field1,omitempty"` + FieldA *NinOptNative `protobuf:"bytes,200,opt,name=Field200" json:"Field200,omitempty"` + FieldB *bool `protobuf:"varint,210,opt,name=Field210" json:"Field210,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameNinEmbeddedStructUnion) Reset() { *m = CustomNameNinEmbeddedStructUnion{} } +func (*CustomNameNinEmbeddedStructUnion) ProtoMessage() {} + +type CustomNameEnum struct { + FieldA *TheTestEnum `protobuf:"varint,1,opt,name=Field1,enum=test.TheTestEnum" json:"Field1,omitempty"` + FieldB []TheTestEnum `protobuf:"varint,2,rep,name=Field2,enum=test.TheTestEnum" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CustomNameEnum) Reset() { *m = CustomNameEnum{} } +func (*CustomNameEnum) ProtoMessage() {} + +type NoExtensionsMap struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + XXX_extensions []byte `protobuf:"bytes,0,opt" json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NoExtensionsMap) Reset() { *m = NoExtensionsMap{} } +func (*NoExtensionsMap) ProtoMessage() {} + +var extRange_NoExtensionsMap = []proto.ExtensionRange{ + {100, 199}, +} + +func (*NoExtensionsMap) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_NoExtensionsMap +} +func (m *NoExtensionsMap) GetExtensions() *[]byte { + if m.XXX_extensions == nil { + m.XXX_extensions = make([]byte, 0) + } + return &m.XXX_extensions +} + +type Unrecognized struct { + Field1 *string `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *Unrecognized) Reset() { *m = Unrecognized{} } +func (*Unrecognized) ProtoMessage() {} + +type UnrecognizedWithInner struct { + Embedded []*UnrecognizedWithInner_Inner `protobuf:"bytes,1,rep,name=embedded" json:"embedded,omitempty"` + Field2 *string `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnrecognizedWithInner) Reset() { *m = UnrecognizedWithInner{} } +func (*UnrecognizedWithInner) ProtoMessage() {} + +type UnrecognizedWithInner_Inner struct { + Field1 *uint32 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *UnrecognizedWithInner_Inner) Reset() { *m = UnrecognizedWithInner_Inner{} } +func (*UnrecognizedWithInner_Inner) ProtoMessage() {} + +type UnrecognizedWithEmbed struct { + UnrecognizedWithEmbed_Embedded `protobuf:"bytes,1,opt,name=embedded,embedded=embedded" json:"embedded"` + Field2 *string `protobuf:"bytes,2,opt,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnrecognizedWithEmbed) Reset() { *m = UnrecognizedWithEmbed{} } +func (*UnrecognizedWithEmbed) ProtoMessage() {} + +type UnrecognizedWithEmbed_Embedded struct { + Field1 *uint32 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` +} + +func (m *UnrecognizedWithEmbed_Embedded) Reset() { *m = UnrecognizedWithEmbed_Embedded{} } +func (*UnrecognizedWithEmbed_Embedded) ProtoMessage() {} + +var E_FieldA = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*float64)(nil), + Field: 100, + Name: "test.FieldA", + Tag: "fixed64,100,opt,name=FieldA", +} + +var E_FieldB = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*NinOptNative)(nil), + Field: 101, + Name: "test.FieldB", + Tag: "bytes,101,opt,name=FieldB", +} + +var E_FieldC = &proto.ExtensionDesc{ + ExtendedType: (*MyExtendable)(nil), + ExtensionType: (*NinEmbeddedStruct)(nil), + Field: 102, + Name: "test.FieldC", + Tag: "bytes,102,opt,name=FieldC", +} + +var E_FieldA1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*float64)(nil), + Field: 100, + Name: "test.FieldA1", + Tag: "fixed64,100,opt,name=FieldA1", +} + +var E_FieldB1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*NinOptNative)(nil), + Field: 101, + Name: "test.FieldB1", + Tag: "bytes,101,opt,name=FieldB1", +} + +var E_FieldC1 = &proto.ExtensionDesc{ + ExtendedType: (*NoExtensionsMap)(nil), + ExtensionType: (*NinEmbeddedStruct)(nil), + Field: 102, + Name: "test.FieldC1", + Tag: "bytes,102,opt,name=FieldC1", +} + +func init() { + proto.RegisterEnum("test.TheTestEnum", TheTestEnum_name, TheTestEnum_value) + proto.RegisterEnum("test.AnotherTestEnum", AnotherTestEnum_name, AnotherTestEnum_value) + proto.RegisterEnum("test.NestedDefinition_NestedEnum", NestedDefinition_NestedEnum_name, NestedDefinition_NestedEnum_value) + proto.RegisterExtension(E_FieldA) + proto.RegisterExtension(E_FieldB) + proto.RegisterExtension(E_FieldC) + proto.RegisterExtension(E_FieldA1) + proto.RegisterExtension(E_FieldB1) + proto.RegisterExtension(E_FieldC1) +} +func (this *NidOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepPackedNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepPackedNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidEmbeddedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinEmbeddedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidNestedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinNestedStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomDash) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepCustom) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNativeUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinEmbeddedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinNestedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Tree) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *OrBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AndBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Leaf) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *DeepTree) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *ADeepBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AndDeepBranch) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *DeepLeaf) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Nil) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NidRepEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinRepEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptEnumDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AnotherNinOptEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *AnotherNinOptEnumDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Timer) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *MyExtendable) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *OtherExtenable) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition_NestedMessage) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NestedScope) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NinOptNativeDefault) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomContainer) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNidOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinOptNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinRepNative) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinStruct) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameCustomType) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameNinEmbeddedStructUnion) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *CustomNameEnum) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *NoExtensionsMap) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *Unrecognized) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithInner) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithInner_Inner) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithEmbed) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func (this *UnrecognizedWithEmbed_Embedded) Description() (desc *google_protobuf.FileDescriptorSet) { + return ThetestDescription() +} +func ThetestDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("thetest.proto"), + Package: func(v string) *string { return &v }("test"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NinRepPackedNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }}, + }, {Name: func(v string) *string { return &v }("NidOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + }, {Name: func(v string) *string { return &v }("NidEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }, {Name: func(v string) *string { return &v }("NidNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidRepStruct"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinNestedStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStruct"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinRepStruct"), + }}, + }, {Name: func(v string) *string { return &v }("NidOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomDash"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x34, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2d, 0x64, 0x61, 0x73, 0x68, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NidRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepCustom"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinOptStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("NinNestedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNativeUnion"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptStructUnion"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStructUnion"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Tree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Or"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.OrBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Leaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("OrBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Leaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("StrValue"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepTree"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.ADeepBranch"), + }, {Name: func(v string) *string { return &v }("And"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.AndDeepBranch"), + }, {Name: func(v string) *string { return &v }("Leaf"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepLeaf"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("ADeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Down"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("AndDeepBranch"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Left"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Right"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.DeepTree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("DeepLeaf"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Tree"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.Tree"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("Nil")}, {Name: func(v string) *string { return &v }("NidOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NidRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("NinRepEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + DefaultValue: func(v string) *string { return &v }("C"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + }}, + }, {Name: func(v string) *string { return &v }("AnotherNinOptEnumDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.AnotherTestEnum"), + DefaultValue: func(v string) *string { return &v }("E"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Timer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Time1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Time2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Data"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("MyExtendable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("OtherExtenable"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("M"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.MyExtendable"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(14), + End: func(v int32) *int32 { return &v }(17), + }, {Start: func(v int32) *int32 { return &v }(10), + End: func(v int32) *int32 { return &v }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("NestedDefinition"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("EnumField"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("NM"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedMessage"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedField1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + }, {Name: func(v string) *string { return &v }("NNM"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedMsg"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("NestedNestedField1"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("NestedEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_NESTED"), + Number: func(v int32) *int32 { return &v }(1), + }}, + }}, + }, {Name: func(v string) *string { return &v }("NestedScope"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage.NestedNestedMsg"), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedEnum"), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NestedDefinition.NestedMessage"), + }}, + }, {Name: func(v string) *string { return &v }("NinOptNativeDefault"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + DefaultValue: func(v string) *string { return &v }("1234.1234"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("true"), + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + DefaultValue: func(v string) *string { return &v }("1234"), + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64001: proto.NewExtension([]byte{0x88, 0xa0, 0x1f, 0x1}), 64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("CustomContainer"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("CustomStruct"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptCustom"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNidOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinOptNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x5, 0x46, 0x69, 0x65, 0x6c, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinRepNative"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(18), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field9"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(7), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field10"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(15), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }, {Name: func(v string) *string { return &v }("Field11"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(6), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4b})}}, + }, {Name: func(v string) *string { return &v }("Field12"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(16), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4e})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinStruct"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45})}}, + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(17), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x46})}}, + }, {Name: func(v string) *string { return &v }("Field8"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x47})}}, + }, {Name: func(v string) *string { return &v }("Field13"), + Number: func(v int32) *int32 { return &v }(13), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x48})}}, + }, {Name: func(v string) *string { return &v }("Field14"), + Number: func(v int32) *int32 { return &v }(14), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49})}}, + }, {Name: func(v string) *string { return &v }("Field15"), + Number: func(v int32) *int32 { return &v }(15), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4a})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameCustomType"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Id"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }, {Name: func(v string) *string { return &v }("Ids"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x4, 0x55, 0x75, 0x69, 0x64}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x43})}}, + }, {Name: func(v string) *string { return &v }("Values"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65003: proto.NewExtension([]byte{0xda, 0xde, 0x1f, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x2f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x2e, 0x55, 0x69, 0x6e, 0x74, 0x31, 0x32, 0x38}), 65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44})}}, + }}, + }, {Name: func(v string) *string { return &v }("CustomNameNinEmbeddedStructUnion"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NidOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field200"), + Number: func(v int32) *int32 { return &v }(200), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field210"), + Number: func(v int32) *int32 { return &v }(210), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64009: proto.NewExtension([]byte{0xc8, 0xa0, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("CustomNameEnum"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x41})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".test.TheTestEnum"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65004: proto.NewExtension([]byte{0xe2, 0xde, 0x1f, 0x6, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42})}}, + }}, + }, {Name: func(v string) *string { return &v }("NoExtensionsMap"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(100), + End: func(v int32) *int32 { return &v }(200), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64005: proto.NewExtension([]byte{0xa8, 0xa0, 0x1f, 0x0}), 64025: proto.NewExtension([]byte{0xc8, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("Unrecognized"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithInner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithInner.Inner"), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Inner"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }, {Name: func(v string) *string { return &v }("UnrecognizedWithEmbed"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("embedded"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.UnrecognizedWithEmbed.Embedded"), + Options: &google_protobuf.FieldOptions{XXX_extensions: map[int32]proto.Extension{65001: proto.NewExtension([]byte{0xc8, 0xde, 0x1f, 0x0}), 65002: proto.NewExtension([]byte{0xd0, 0xde, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Embedded"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }}, + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("TheTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }, {Name: func(v string) *string { return &v }("AnotherTestEnum"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("D"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("E"), + Number: func(v int32) *int32 { return &v }(11), + }}, + Options: &google_protobuf.EnumOptions{XXX_extensions: map[int32]proto.Extension{62001: proto.NewExtension([]byte{0x88, 0xa3, 0x1e, 0x0})}}, + }}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("FieldA"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldB"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldC"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.MyExtendable"), + }, {Name: func(v string) *string { return &v }("FieldA1"), + Number: func(v int32) *int32 { return &v }(100), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldB1"), + Number: func(v int32) *int32 { return &v }(101), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinOptNative"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }, {Name: func(v string) *string { return &v }("FieldC1"), + Number: func(v int32) *int32 { return &v }(102), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".test.NinEmbeddedStruct"), + Extendee: func(v string) *string { return &v }(".test.NoExtensionsMap"), + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63005: proto.NewExtension([]byte{0xe8, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63016: proto.NewExtension([]byte{0xc0, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x0}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x0}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1}), 63021: proto.NewExtension([]byte{0xe8, 0xe2, 0x1e, 0x0}), 63022: proto.NewExtension([]byte{0xf0, 0xe2, 0x1e, 0x1}), 63023: proto.NewExtension([]byte{0xf8, 0xe2, 0x1e, 0x0}), 63024: proto.NewExtension([]byte{0x80, 0xe3, 0x1e, 0x0})}}, + }}, + } +} +func (x TheTestEnum) String() string { + s, ok := TheTestEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x AnotherTestEnum) String() string { + s, ok := AnotherTestEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (x NestedDefinition_NestedEnum) String() string { + s, ok := NestedDefinition_NestedEnum_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *NidOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptNative) + if !ok { + return fmt.Errorf("that is not of type *NidOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptNativebut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if this.Field2 != that1.Field2 { + return false + } + if this.Field3 != that1.Field3 { + return false + } + if this.Field4 != that1.Field4 { + return false + } + if this.Field5 != that1.Field5 { + return false + } + if this.Field6 != that1.Field6 { + return false + } + if this.Field7 != that1.Field7 { + return false + } + if this.Field8 != that1.Field8 { + return false + } + if this.Field9 != that1.Field9 { + return false + } + if this.Field10 != that1.Field10 { + return false + } + if this.Field11 != that1.Field11 { + return false + } + if this.Field12 != that1.Field12 { + return false + } + if this.Field13 != that1.Field13 { + return false + } + if this.Field14 != that1.Field14 { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNative) + if !ok { + return fmt.Errorf("that is not of type *NinOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativebut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", *this.Field8, *that1.Field8) + } + } else if this.Field8 != nil { + return fmt.Errorf("this.Field8 == nil && that.Field8 != nil") + } else if that1.Field8 != nil { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", *this.Field9, *that1.Field9) + } + } else if this.Field9 != nil { + return fmt.Errorf("this.Field9 == nil && that.Field9 != nil") + } else if that1.Field9 != nil { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", *this.Field10, *that1.Field10) + } + } else if this.Field10 != nil { + return fmt.Errorf("this.Field10 == nil && that.Field10 != nil") + } else if that1.Field10 != nil { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", *this.Field11, *that1.Field11) + } + } else if this.Field11 != nil { + return fmt.Errorf("this.Field11 == nil && that.Field11 != nil") + } else if that1.Field11 != nil { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", *this.Field12, *that1.Field12) + } + } else if this.Field12 != nil { + return fmt.Errorf("this.Field12 == nil && that.Field12 != nil") + } else if that1.Field12 != nil { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return false + } + } else if this.Field8 != nil { + return false + } else if that1.Field8 != nil { + return false + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return false + } + } else if this.Field9 != nil { + return false + } else if that1.Field9 != nil { + return false + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return false + } + } else if this.Field10 != nil { + return false + } else if that1.Field10 != nil { + return false + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return false + } + } else if this.Field11 != nil { + return false + } else if that1.Field11 != nil { + return false + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return false + } + } else if this.Field12 != nil { + return false + } else if that1.Field12 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepNative) + if !ok { + return fmt.Errorf("that is not of type *NidRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepNative) + if !ok { + return fmt.Errorf("that is not of type *NinRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepPackedNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepPackedNative) + if !ok { + return fmt.Errorf("that is not of type *NidRepPackedNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepPackedNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepPackedNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepPackedNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepPackedNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepPackedNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepPackedNative) + if !ok { + return fmt.Errorf("that is not of type *NinRepPackedNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepPackedNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepPackedNativebut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field9) != len(that1.Field9) { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", len(this.Field9), len(that1.Field9)) + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return fmt.Errorf("Field9 this[%v](%v) Not Equal that[%v](%v)", i, this.Field9[i], i, that1.Field9[i]) + } + } + if len(this.Field10) != len(that1.Field10) { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", len(this.Field10), len(that1.Field10)) + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return fmt.Errorf("Field10 this[%v](%v) Not Equal that[%v](%v)", i, this.Field10[i], i, that1.Field10[i]) + } + } + if len(this.Field11) != len(that1.Field11) { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", len(this.Field11), len(that1.Field11)) + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return fmt.Errorf("Field11 this[%v](%v) Not Equal that[%v](%v)", i, this.Field11[i], i, that1.Field11[i]) + } + } + if len(this.Field12) != len(that1.Field12) { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", len(this.Field12), len(that1.Field12)) + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return fmt.Errorf("Field12 this[%v](%v) Not Equal that[%v](%v)", i, this.Field12[i], i, that1.Field12[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepPackedNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepPackedNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if this.Field4[i] != that1.Field4[i] { + return false + } + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if this.Field5[i] != that1.Field5[i] { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if this.Field8[i] != that1.Field8[i] { + return false + } + } + if len(this.Field9) != len(that1.Field9) { + return false + } + for i := range this.Field9 { + if this.Field9[i] != that1.Field9[i] { + return false + } + } + if len(this.Field10) != len(that1.Field10) { + return false + } + for i := range this.Field10 { + if this.Field10[i] != that1.Field10[i] { + return false + } + } + if len(this.Field11) != len(that1.Field11) { + return false + } + for i := range this.Field11 { + if this.Field11[i] != that1.Field11[i] { + return false + } + } + if len(this.Field12) != len(that1.Field12) { + return false + } + for i := range this.Field12 { + if this.Field12[i] != that1.Field12[i] { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptStruct) + if !ok { + return fmt.Errorf("that is not of type *NidOptStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptStructbut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(&that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(&that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if !this.Field8.Equal(&that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field13 != that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if this.Field2 != that1.Field2 { + return false + } + if !this.Field3.Equal(&that1.Field3) { + return false + } + if !this.Field4.Equal(&that1.Field4) { + return false + } + if this.Field6 != that1.Field6 { + return false + } + if this.Field7 != that1.Field7 { + return false + } + if !this.Field8.Equal(&that1.Field8) { + return false + } + if this.Field13 != that1.Field13 { + return false + } + if this.Field14 != that1.Field14 { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptStruct) + if !ok { + return fmt.Errorf("that is not of type *NinOptStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptStructbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if !this.Field8.Equal(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !this.Field4.Equal(that1.Field4) { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if !this.Field8.Equal(that1.Field8) { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepStruct) + if !ok { + return fmt.Errorf("that is not of type *NidRepStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepStructbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if !this.Field3[i].Equal(&that1.Field3[i]) { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if !this.Field4[i].Equal(&that1.Field4[i]) { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if !this.Field8[i].Equal(&that1.Field8[i]) { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if !this.Field3[i].Equal(&that1.Field3[i]) { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if !this.Field4[i].Equal(&that1.Field4[i]) { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if !this.Field8[i].Equal(&that1.Field8[i]) { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepStruct) + if !ok { + return fmt.Errorf("that is not of type *NinRepStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepStructbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if !this.Field3[i].Equal(that1.Field3[i]) { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if len(this.Field4) != len(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", len(this.Field4), len(that1.Field4)) + } + for i := range this.Field4 { + if !this.Field4[i].Equal(that1.Field4[i]) { + return fmt.Errorf("Field4 this[%v](%v) Not Equal that[%v](%v)", i, this.Field4[i], i, that1.Field4[i]) + } + } + if len(this.Field6) != len(that1.Field6) { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", len(this.Field6), len(that1.Field6)) + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return fmt.Errorf("Field6 this[%v](%v) Not Equal that[%v](%v)", i, this.Field6[i], i, that1.Field6[i]) + } + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if len(this.Field8) != len(that1.Field8) { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", len(this.Field8), len(that1.Field8)) + } + for i := range this.Field8 { + if !this.Field8[i].Equal(that1.Field8[i]) { + return fmt.Errorf("Field8 this[%v](%v) Not Equal that[%v](%v)", i, this.Field8[i], i, that1.Field8[i]) + } + } + if len(this.Field13) != len(that1.Field13) { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", len(this.Field13), len(that1.Field13)) + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return fmt.Errorf("Field13 this[%v](%v) Not Equal that[%v](%v)", i, this.Field13[i], i, that1.Field13[i]) + } + } + if len(this.Field14) != len(that1.Field14) { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", len(this.Field14), len(that1.Field14)) + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return fmt.Errorf("Field14 this[%v](%v) Not Equal that[%v](%v)", i, this.Field14[i], i, that1.Field14[i]) + } + } + if len(this.Field15) != len(that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", len(this.Field15), len(that1.Field15)) + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return fmt.Errorf("Field15 this[%v](%v) Not Equal that[%v](%v)", i, this.Field15[i], i, that1.Field15[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if !this.Field3[i].Equal(that1.Field3[i]) { + return false + } + } + if len(this.Field4) != len(that1.Field4) { + return false + } + for i := range this.Field4 { + if !this.Field4[i].Equal(that1.Field4[i]) { + return false + } + } + if len(this.Field6) != len(that1.Field6) { + return false + } + for i := range this.Field6 { + if this.Field6[i] != that1.Field6[i] { + return false + } + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if len(this.Field8) != len(that1.Field8) { + return false + } + for i := range this.Field8 { + if !this.Field8[i].Equal(that1.Field8[i]) { + return false + } + } + if len(this.Field13) != len(that1.Field13) { + return false + } + for i := range this.Field13 { + if this.Field13[i] != that1.Field13[i] { + return false + } + } + if len(this.Field14) != len(that1.Field14) { + return false + } + for i := range this.Field14 { + if this.Field14[i] != that1.Field14[i] { + return false + } + } + if len(this.Field15) != len(that1.Field15) { + return false + } + for i := range this.Field15 { + if !bytes.Equal(this.Field15[i], that1.Field15[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidEmbeddedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidEmbeddedStruct) + if !ok { + return fmt.Errorf("that is not of type *NidEmbeddedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidEmbeddedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidEmbeddedStructbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(&that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidEmbeddedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidEmbeddedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(&that1.Field200) { + return false + } + if this.Field210 != that1.Field210 { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinEmbeddedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinEmbeddedStruct) + if !ok { + return fmt.Errorf("that is not of type *NinEmbeddedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinEmbeddedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinEmbeddedStructbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", *this.Field210, *that1.Field210) + } + } else if this.Field210 != nil { + return fmt.Errorf("this.Field210 == nil && that.Field210 != nil") + } else if that1.Field210 != nil { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinEmbeddedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinEmbeddedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(that1.Field200) { + return false + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return false + } + } else if this.Field210 != nil { + return false + } else if that1.Field210 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidNestedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidNestedStruct) + if !ok { + return fmt.Errorf("that is not of type *NidNestedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidNestedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidNestedStructbut is not nil && this == nil") + } + if !this.Field1.Equal(&that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if !this.Field2[i].Equal(&that1.Field2[i]) { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidNestedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidNestedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(&that1.Field1) { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if !this.Field2[i].Equal(&that1.Field2[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinNestedStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinNestedStruct) + if !ok { + return fmt.Errorf("that is not of type *NinNestedStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinNestedStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinNestedStructbut is not nil && this == nil") + } + if !this.Field1.Equal(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if !this.Field2[i].Equal(that1.Field2[i]) { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinNestedStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinNestedStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(that1.Field1) { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if !this.Field2[i].Equal(that1.Field2[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptCustom) + if !ok { + return fmt.Errorf("that is not of type *NidOptCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptCustombut is not nil && this == nil") + } + if !this.Id.Equal(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id) + } + if !this.Value.Equal(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Id.Equal(that1.Id) { + return false + } + if !this.Value.Equal(that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomDash) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomDash) + if !ok { + return fmt.Errorf("that is not of type *CustomDash") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomDash but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomDashbut is not nil && this == nil") + } + if that1.Value == nil { + if this.Value != nil { + return fmt.Errorf("this.Value != nil && that1.Value == nil") + } + } else if !this.Value.Equal(*that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomDash) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomDash) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Value == nil { + if this.Value != nil { + return false + } + } else if !this.Value.Equal(*that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptCustom) + if !ok { + return fmt.Errorf("that is not of type *NinOptCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptCustombut is not nil && this == nil") + } + if that1.Id == nil { + if this.Id != nil { + return fmt.Errorf("this.Id != nil && that1.Id == nil") + } + } else if !this.Id.Equal(*that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", this.Id, that1.Id) + } + if that1.Value == nil { + if this.Value != nil { + return fmt.Errorf("this.Value != nil && that1.Value == nil") + } + } else if !this.Value.Equal(*that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.Id == nil { + if this.Id != nil { + return false + } + } else if !this.Id.Equal(*that1.Id) { + return false + } + if that1.Value == nil { + if this.Value != nil { + return false + } + } else if !this.Value.Equal(*that1.Value) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepCustom) + if !ok { + return fmt.Errorf("that is not of type *NidRepCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepCustombut is not nil && this == nil") + } + if len(this.Id) != len(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", len(this.Id), len(that1.Id)) + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return fmt.Errorf("Id this[%v](%v) Not Equal that[%v](%v)", i, this.Id[i], i, that1.Id[i]) + } + } + if len(this.Value) != len(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", len(this.Value), len(that1.Value)) + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return fmt.Errorf("Value this[%v](%v) Not Equal that[%v](%v)", i, this.Value[i], i, that1.Value[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Id) != len(that1.Id) { + return false + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return false + } + } + if len(this.Value) != len(that1.Value) { + return false + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepCustom) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepCustom) + if !ok { + return fmt.Errorf("that is not of type *NinRepCustom") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepCustom but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepCustombut is not nil && this == nil") + } + if len(this.Id) != len(that1.Id) { + return fmt.Errorf("Id this(%v) Not Equal that(%v)", len(this.Id), len(that1.Id)) + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return fmt.Errorf("Id this[%v](%v) Not Equal that[%v](%v)", i, this.Id[i], i, that1.Id[i]) + } + } + if len(this.Value) != len(that1.Value) { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", len(this.Value), len(that1.Value)) + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return fmt.Errorf("Value this[%v](%v) Not Equal that[%v](%v)", i, this.Value[i], i, that1.Value[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepCustom) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepCustom) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Id) != len(that1.Id) { + return false + } + for i := range this.Id { + if !this.Id[i].Equal(that1.Id[i]) { + return false + } + } + if len(this.Value) != len(that1.Value) { + return false + } + for i := range this.Value { + if !this.Value[i].Equal(that1.Value[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNativeUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNativeUnion) + if !ok { + return fmt.Errorf("that is not of type *NinOptNativeUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNativeUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativeUnionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNativeUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNativeUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinOptStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptStructUnionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !this.Field4.Equal(that1.Field4) { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !this.Field4.Equal(that1.Field4) { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinEmbeddedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinEmbeddedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinEmbeddedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinEmbeddedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinEmbeddedStructUnionbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.Field200.Equal(that1.Field200) { + return fmt.Errorf("Field200 this(%v) Not Equal that(%v)", this.Field200, that1.Field200) + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", *this.Field210, *that1.Field210) + } + } else if this.Field210 != nil { + return fmt.Errorf("this.Field210 == nil && that.Field210 != nil") + } else if that1.Field210 != nil { + return fmt.Errorf("Field210 this(%v) Not Equal that(%v)", this.Field210, that1.Field210) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinEmbeddedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinEmbeddedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.Field200.Equal(that1.Field200) { + return false + } + if this.Field210 != nil && that1.Field210 != nil { + if *this.Field210 != *that1.Field210 { + return false + } + } else if this.Field210 != nil { + return false + } else if that1.Field210 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinNestedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinNestedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *NinNestedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinNestedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinNestedStructUnionbut is not nil && this == nil") + } + if !this.Field1.Equal(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !this.Field2.Equal(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !this.Field3.Equal(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinNestedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinNestedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Field1.Equal(that1.Field1) { + return false + } + if !this.Field2.Equal(that1.Field2) { + return false + } + if !this.Field3.Equal(that1.Field3) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Tree) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Tree) + if !ok { + return fmt.Errorf("that is not of type *Tree") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Tree but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Treebut is not nil && this == nil") + } + if !this.Or.Equal(that1.Or) { + return fmt.Errorf("Or this(%v) Not Equal that(%v)", this.Or, that1.Or) + } + if !this.And.Equal(that1.And) { + return fmt.Errorf("And this(%v) Not Equal that(%v)", this.And, that1.And) + } + if !this.Leaf.Equal(that1.Leaf) { + return fmt.Errorf("Leaf this(%v) Not Equal that(%v)", this.Leaf, that1.Leaf) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Tree) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Tree) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Or.Equal(that1.Or) { + return false + } + if !this.And.Equal(that1.And) { + return false + } + if !this.Leaf.Equal(that1.Leaf) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OrBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OrBranch) + if !ok { + return fmt.Errorf("that is not of type *OrBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OrBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OrBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OrBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OrBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AndBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AndBranch) + if !ok { + return fmt.Errorf("that is not of type *AndBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AndBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AndBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AndBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AndBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Leaf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Leaf) + if !ok { + return fmt.Errorf("that is not of type *Leaf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Leaf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Leafbut is not nil && this == nil") + } + if this.Value != that1.Value { + return fmt.Errorf("Value this(%v) Not Equal that(%v)", this.Value, that1.Value) + } + if this.StrValue != that1.StrValue { + return fmt.Errorf("StrValue this(%v) Not Equal that(%v)", this.StrValue, that1.StrValue) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Leaf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Leaf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Value != that1.Value { + return false + } + if this.StrValue != that1.StrValue { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *DeepTree) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*DeepTree) + if !ok { + return fmt.Errorf("that is not of type *DeepTree") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *DeepTree but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *DeepTreebut is not nil && this == nil") + } + if !this.Down.Equal(that1.Down) { + return fmt.Errorf("Down this(%v) Not Equal that(%v)", this.Down, that1.Down) + } + if !this.And.Equal(that1.And) { + return fmt.Errorf("And this(%v) Not Equal that(%v)", this.And, that1.And) + } + if !this.Leaf.Equal(that1.Leaf) { + return fmt.Errorf("Leaf this(%v) Not Equal that(%v)", this.Leaf, that1.Leaf) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *DeepTree) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*DeepTree) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Down.Equal(that1.Down) { + return false + } + if !this.And.Equal(that1.And) { + return false + } + if !this.Leaf.Equal(that1.Leaf) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *ADeepBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*ADeepBranch) + if !ok { + return fmt.Errorf("that is not of type *ADeepBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *ADeepBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *ADeepBranchbut is not nil && this == nil") + } + if !this.Down.Equal(&that1.Down) { + return fmt.Errorf("Down this(%v) Not Equal that(%v)", this.Down, that1.Down) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *ADeepBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*ADeepBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Down.Equal(&that1.Down) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AndDeepBranch) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AndDeepBranch) + if !ok { + return fmt.Errorf("that is not of type *AndDeepBranch") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AndDeepBranch but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AndDeepBranchbut is not nil && this == nil") + } + if !this.Left.Equal(&that1.Left) { + return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left) + } + if !this.Right.Equal(&that1.Right) { + return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AndDeepBranch) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AndDeepBranch) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Left.Equal(&that1.Left) { + return false + } + if !this.Right.Equal(&that1.Right) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *DeepLeaf) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*DeepLeaf) + if !ok { + return fmt.Errorf("that is not of type *DeepLeaf") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *DeepLeaf but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *DeepLeafbut is not nil && this == nil") + } + if !this.Tree.Equal(&that1.Tree) { + return fmt.Errorf("Tree this(%v) Not Equal that(%v)", this.Tree, that1.Tree) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *DeepLeaf) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*DeepLeaf) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Tree.Equal(&that1.Tree) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Nil) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Nil) + if !ok { + return fmt.Errorf("that is not of type *Nil") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Nil but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Nilbut is not nil && this == nil") + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Nil) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Nil) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidOptEnum) + if !ok { + return fmt.Errorf("that is not of type *NidOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidOptEnumbut is not nil && this == nil") + } + if this.Field1 != that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != that1.Field1 { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptEnum) + if !ok { + return fmt.Errorf("that is not of type *NinOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptEnumbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NidRepEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NidRepEnum) + if !ok { + return fmt.Errorf("that is not of type *NidRepEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NidRepEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NidRepEnumbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NidRepEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NidRepEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinRepEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinRepEnum) + if !ok { + return fmt.Errorf("that is not of type *NinRepEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinRepEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinRepEnumbut is not nil && this == nil") + } + if len(this.Field1) != len(that1.Field1) { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", len(this.Field1), len(that1.Field1)) + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return fmt.Errorf("Field1 this[%v](%v) Not Equal that[%v](%v)", i, this.Field1[i], i, that1.Field1[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinRepEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinRepEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field1) != len(that1.Field1) { + return false + } + for i := range this.Field1 { + if this.Field1[i] != that1.Field1[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptEnumDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptEnumDefault) + if !ok { + return fmt.Errorf("that is not of type *NinOptEnumDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptEnumDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptEnumDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptEnumDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptEnumDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AnotherNinOptEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AnotherNinOptEnum) + if !ok { + return fmt.Errorf("that is not of type *AnotherNinOptEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AnotherNinOptEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AnotherNinOptEnumbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AnotherNinOptEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AnotherNinOptEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *AnotherNinOptEnumDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*AnotherNinOptEnumDefault) + if !ok { + return fmt.Errorf("that is not of type *AnotherNinOptEnumDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *AnotherNinOptEnumDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *AnotherNinOptEnumDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *AnotherNinOptEnumDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*AnotherNinOptEnumDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Timer) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Timer) + if !ok { + return fmt.Errorf("that is not of type *Timer") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Timer but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Timerbut is not nil && this == nil") + } + if this.Time1 != that1.Time1 { + return fmt.Errorf("Time1 this(%v) Not Equal that(%v)", this.Time1, that1.Time1) + } + if this.Time2 != that1.Time2 { + return fmt.Errorf("Time2 this(%v) Not Equal that(%v)", this.Time2, that1.Time2) + } + if !bytes.Equal(this.Data, that1.Data) { + return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Timer) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Timer) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Time1 != that1.Time1 { + return false + } + if this.Time2 != that1.Time2 { + return false + } + if !bytes.Equal(this.Data, that1.Data) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *MyExtendable) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*MyExtendable) + if !ok { + return fmt.Errorf("that is not of type *MyExtendable") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *MyExtendable but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *MyExtendablebut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return fmt.Errorf("XXX_extensions this[%v](%v) Not Equal that[%v](%v)", k, this.XXX_extensions[k], k, that1.XXX_extensions[k]) + } + } else { + return fmt.Errorf("XXX_extensions[%v] Not In that", k) + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return fmt.Errorf("XXX_extensions[%v] Not In this", k) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *MyExtendable) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*MyExtendable) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return false + } + } else { + return false + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OtherExtenable) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OtherExtenable) + if !ok { + return fmt.Errorf("that is not of type *OtherExtenable") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OtherExtenable but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OtherExtenablebut is not nil && this == nil") + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if !this.M.Equal(that1.M) { + return fmt.Errorf("M this(%v) Not Equal that(%v)", this.M, that1.M) + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return fmt.Errorf("XXX_extensions this[%v](%v) Not Equal that[%v](%v)", k, this.XXX_extensions[k], k, that1.XXX_extensions[k]) + } + } else { + return fmt.Errorf("XXX_extensions[%v] Not In that", k) + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return fmt.Errorf("XXX_extensions[%v] Not In this", k) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OtherExtenable) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OtherExtenable) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if !this.M.Equal(that1.M) { + return false + } + for k, v := range this.XXX_extensions { + if v2, ok := that1.XXX_extensions[k]; ok { + if !v.Equal(&v2) { + return false + } + } else { + return false + } + } + for k := range that1.XXX_extensions { + if _, ok := this.XXX_extensions[k]; !ok { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinitionbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.EnumField != nil && that1.EnumField != nil { + if *this.EnumField != *that1.EnumField { + return fmt.Errorf("EnumField this(%v) Not Equal that(%v)", *this.EnumField, *that1.EnumField) + } + } else if this.EnumField != nil { + return fmt.Errorf("this.EnumField == nil && that.EnumField != nil") + } else if that1.EnumField != nil { + return fmt.Errorf("EnumField this(%v) Not Equal that(%v)", this.EnumField, that1.EnumField) + } + if !this.NNM.Equal(that1.NNM) { + return fmt.Errorf("NNM this(%v) Not Equal that(%v)", this.NNM, that1.NNM) + } + if !this.NM.Equal(that1.NM) { + return fmt.Errorf("NM this(%v) Not Equal that(%v)", this.NM, that1.NM) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.EnumField != nil && that1.EnumField != nil { + if *this.EnumField != *that1.EnumField { + return false + } + } else if this.EnumField != nil { + return false + } else if that1.EnumField != nil { + return false + } + if !this.NNM.Equal(that1.NNM) { + return false + } + if !this.NM.Equal(that1.NM) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition_NestedMessage) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition_NestedMessage) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition_NestedMessage") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition_NestedMessage but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinition_NestedMessagebut is not nil && this == nil") + } + if this.NestedField1 != nil && that1.NestedField1 != nil { + if *this.NestedField1 != *that1.NestedField1 { + return fmt.Errorf("NestedField1 this(%v) Not Equal that(%v)", *this.NestedField1, *that1.NestedField1) + } + } else if this.NestedField1 != nil { + return fmt.Errorf("this.NestedField1 == nil && that.NestedField1 != nil") + } else if that1.NestedField1 != nil { + return fmt.Errorf("NestedField1 this(%v) Not Equal that(%v)", this.NestedField1, that1.NestedField1) + } + if !this.NNM.Equal(that1.NNM) { + return fmt.Errorf("NNM this(%v) Not Equal that(%v)", this.NNM, that1.NNM) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition_NestedMessage) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition_NestedMessage) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.NestedField1 != nil && that1.NestedField1 != nil { + if *this.NestedField1 != *that1.NestedField1 { + return false + } + } else if this.NestedField1 != nil { + return false + } else if that1.NestedField1 != nil { + return false + } + if !this.NNM.Equal(that1.NNM) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedDefinition_NestedMessage_NestedNestedMsg) + if !ok { + return fmt.Errorf("that is not of type *NestedDefinition_NestedMessage_NestedNestedMsg") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedDefinition_NestedMessage_NestedNestedMsg but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedDefinition_NestedMessage_NestedNestedMsgbut is not nil && this == nil") + } + if this.NestedNestedField1 != nil && that1.NestedNestedField1 != nil { + if *this.NestedNestedField1 != *that1.NestedNestedField1 { + return fmt.Errorf("NestedNestedField1 this(%v) Not Equal that(%v)", *this.NestedNestedField1, *that1.NestedNestedField1) + } + } else if this.NestedNestedField1 != nil { + return fmt.Errorf("this.NestedNestedField1 == nil && that.NestedNestedField1 != nil") + } else if that1.NestedNestedField1 != nil { + return fmt.Errorf("NestedNestedField1 this(%v) Not Equal that(%v)", this.NestedNestedField1, that1.NestedNestedField1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedDefinition_NestedMessage_NestedNestedMsg) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.NestedNestedField1 != nil && that1.NestedNestedField1 != nil { + if *this.NestedNestedField1 != *that1.NestedNestedField1 { + return false + } + } else if this.NestedNestedField1 != nil { + return false + } else if that1.NestedNestedField1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NestedScope) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NestedScope) + if !ok { + return fmt.Errorf("that is not of type *NestedScope") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NestedScope but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NestedScopebut is not nil && this == nil") + } + if !this.A.Equal(that1.A) { + return fmt.Errorf("A this(%v) Not Equal that(%v)", this.A, that1.A) + } + if this.B != nil && that1.B != nil { + if *this.B != *that1.B { + return fmt.Errorf("B this(%v) Not Equal that(%v)", *this.B, *that1.B) + } + } else if this.B != nil { + return fmt.Errorf("this.B == nil && that.B != nil") + } else if that1.B != nil { + return fmt.Errorf("B this(%v) Not Equal that(%v)", this.B, that1.B) + } + if !this.C.Equal(that1.C) { + return fmt.Errorf("C this(%v) Not Equal that(%v)", this.C, that1.C) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NestedScope) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NestedScope) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.A.Equal(that1.A) { + return false + } + if this.B != nil && that1.B != nil { + if *this.B != *that1.B { + return false + } + } else if this.B != nil { + return false + } else if that1.B != nil { + return false + } + if !this.C.Equal(that1.C) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NinOptNativeDefault) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NinOptNativeDefault) + if !ok { + return fmt.Errorf("that is not of type *NinOptNativeDefault") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NinOptNativeDefault but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NinOptNativeDefaultbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", *this.Field5, *that1.Field5) + } + } else if this.Field5 != nil { + return fmt.Errorf("this.Field5 == nil && that.Field5 != nil") + } else if that1.Field5 != nil { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", this.Field5, that1.Field5) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", *this.Field7, *that1.Field7) + } + } else if this.Field7 != nil { + return fmt.Errorf("this.Field7 == nil && that.Field7 != nil") + } else if that1.Field7 != nil { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", this.Field7, that1.Field7) + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", *this.Field8, *that1.Field8) + } + } else if this.Field8 != nil { + return fmt.Errorf("this.Field8 == nil && that.Field8 != nil") + } else if that1.Field8 != nil { + return fmt.Errorf("Field8 this(%v) Not Equal that(%v)", this.Field8, that1.Field8) + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", *this.Field9, *that1.Field9) + } + } else if this.Field9 != nil { + return fmt.Errorf("this.Field9 == nil && that.Field9 != nil") + } else if that1.Field9 != nil { + return fmt.Errorf("Field9 this(%v) Not Equal that(%v)", this.Field9, that1.Field9) + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", *this.Field10, *that1.Field10) + } + } else if this.Field10 != nil { + return fmt.Errorf("this.Field10 == nil && that.Field10 != nil") + } else if that1.Field10 != nil { + return fmt.Errorf("Field10 this(%v) Not Equal that(%v)", this.Field10, that1.Field10) + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", *this.Field11, *that1.Field11) + } + } else if this.Field11 != nil { + return fmt.Errorf("this.Field11 == nil && that.Field11 != nil") + } else if that1.Field11 != nil { + return fmt.Errorf("Field11 this(%v) Not Equal that(%v)", this.Field11, that1.Field11) + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", *this.Field12, *that1.Field12) + } + } else if this.Field12 != nil { + return fmt.Errorf("this.Field12 == nil && that.Field12 != nil") + } else if that1.Field12 != nil { + return fmt.Errorf("Field12 this(%v) Not Equal that(%v)", this.Field12, that1.Field12) + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", *this.Field13, *that1.Field13) + } + } else if this.Field13 != nil { + return fmt.Errorf("this.Field13 == nil && that.Field13 != nil") + } else if that1.Field13 != nil { + return fmt.Errorf("Field13 this(%v) Not Equal that(%v)", this.Field13, that1.Field13) + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", *this.Field14, *that1.Field14) + } + } else if this.Field14 != nil { + return fmt.Errorf("this.Field14 == nil && that.Field14 != nil") + } else if that1.Field14 != nil { + return fmt.Errorf("Field14 this(%v) Not Equal that(%v)", this.Field14, that1.Field14) + } + if !bytes.Equal(this.Field15, that1.Field15) { + return fmt.Errorf("Field15 this(%v) Not Equal that(%v)", this.Field15, that1.Field15) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NinOptNativeDefault) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NinOptNativeDefault) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if this.Field5 != nil && that1.Field5 != nil { + if *this.Field5 != *that1.Field5 { + return false + } + } else if this.Field5 != nil { + return false + } else if that1.Field5 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if this.Field7 != nil && that1.Field7 != nil { + if *this.Field7 != *that1.Field7 { + return false + } + } else if this.Field7 != nil { + return false + } else if that1.Field7 != nil { + return false + } + if this.Field8 != nil && that1.Field8 != nil { + if *this.Field8 != *that1.Field8 { + return false + } + } else if this.Field8 != nil { + return false + } else if that1.Field8 != nil { + return false + } + if this.Field9 != nil && that1.Field9 != nil { + if *this.Field9 != *that1.Field9 { + return false + } + } else if this.Field9 != nil { + return false + } else if that1.Field9 != nil { + return false + } + if this.Field10 != nil && that1.Field10 != nil { + if *this.Field10 != *that1.Field10 { + return false + } + } else if this.Field10 != nil { + return false + } else if that1.Field10 != nil { + return false + } + if this.Field11 != nil && that1.Field11 != nil { + if *this.Field11 != *that1.Field11 { + return false + } + } else if this.Field11 != nil { + return false + } else if that1.Field11 != nil { + return false + } + if this.Field12 != nil && that1.Field12 != nil { + if *this.Field12 != *that1.Field12 { + return false + } + } else if this.Field12 != nil { + return false + } else if that1.Field12 != nil { + return false + } + if this.Field13 != nil && that1.Field13 != nil { + if *this.Field13 != *that1.Field13 { + return false + } + } else if this.Field13 != nil { + return false + } else if that1.Field13 != nil { + return false + } + if this.Field14 != nil && that1.Field14 != nil { + if *this.Field14 != *that1.Field14 { + return false + } + } else if this.Field14 != nil { + return false + } else if that1.Field14 != nil { + return false + } + if !bytes.Equal(this.Field15, that1.Field15) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomContainer) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomContainer) + if !ok { + return fmt.Errorf("that is not of type *CustomContainer") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomContainer but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomContainerbut is not nil && this == nil") + } + if !this.CustomStruct.Equal(&that1.CustomStruct) { + return fmt.Errorf("CustomStruct this(%v) Not Equal that(%v)", this.CustomStruct, that1.CustomStruct) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomContainer) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomContainer) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.CustomStruct.Equal(&that1.CustomStruct) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNidOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNidOptNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNidOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNidOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNidOptNativebut is not nil && this == nil") + } + if this.FieldA != that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if this.FieldC != that1.FieldC { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if this.FieldD != that1.FieldD { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", this.FieldD, that1.FieldD) + } + if this.FieldE != that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if this.FieldG != that1.FieldG { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if this.FieldJ != that1.FieldJ { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if this.FieldK != that1.FieldK { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", this.FieldK, that1.FieldK) + } + if this.FieldL != that1.FieldL { + return fmt.Errorf("FieldL this(%v) Not Equal that(%v)", this.FieldL, that1.FieldL) + } + if this.FieldM != that1.FieldM { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", this.FieldM, that1.FieldM) + } + if this.FieldN != that1.FieldN { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", this.FieldN, that1.FieldN) + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", this.FieldO, that1.FieldO) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNidOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNidOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != that1.FieldA { + return false + } + if this.FieldB != that1.FieldB { + return false + } + if this.FieldC != that1.FieldC { + return false + } + if this.FieldD != that1.FieldD { + return false + } + if this.FieldE != that1.FieldE { + return false + } + if this.FieldF != that1.FieldF { + return false + } + if this.FieldG != that1.FieldG { + return false + } + if this.FieldH != that1.FieldH { + return false + } + if this.FieldI != that1.FieldI { + return false + } + if this.FieldJ != that1.FieldJ { + return false + } + if this.FieldK != that1.FieldK { + return false + } + if this.FieldL != that1.FieldL { + return false + } + if this.FieldM != that1.FieldM { + return false + } + if this.FieldN != that1.FieldN { + return false + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinOptNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinOptNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinOptNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinOptNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinOptNativebut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if this.FieldC != nil && that1.FieldC != nil { + if *this.FieldC != *that1.FieldC { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", *this.FieldC, *that1.FieldC) + } + } else if this.FieldC != nil { + return fmt.Errorf("this.FieldC == nil && that.FieldC != nil") + } else if that1.FieldC != nil { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if this.FieldD != nil && that1.FieldD != nil { + if *this.FieldD != *that1.FieldD { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", *this.FieldD, *that1.FieldD) + } + } else if this.FieldD != nil { + return fmt.Errorf("this.FieldD == nil && that.FieldD != nil") + } else if that1.FieldD != nil { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", this.FieldD, that1.FieldD) + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", *this.FieldE, *that1.FieldE) + } + } else if this.FieldE != nil { + return fmt.Errorf("this.FieldE == nil && that.FieldE != nil") + } else if that1.FieldE != nil { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", *this.FieldF, *that1.FieldF) + } + } else if this.FieldF != nil { + return fmt.Errorf("this.FieldF == nil && that.FieldF != nil") + } else if that1.FieldF != nil { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if this.FieldG != nil && that1.FieldG != nil { + if *this.FieldG != *that1.FieldG { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", *this.FieldG, *that1.FieldG) + } + } else if this.FieldG != nil { + return fmt.Errorf("this.FieldG == nil && that.FieldG != nil") + } else if that1.FieldG != nil { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", *this.FieldH, *that1.FieldH) + } + } else if this.FieldH != nil { + return fmt.Errorf("this.FieldH == nil && that.FieldH != nil") + } else if that1.FieldH != nil { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", *this.FieldI, *that1.FieldI) + } + } else if this.FieldI != nil { + return fmt.Errorf("this.FieldI == nil && that.FieldI != nil") + } else if that1.FieldI != nil { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if this.FieldJ != nil && that1.FieldJ != nil { + if *this.FieldJ != *that1.FieldJ { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", *this.FieldJ, *that1.FieldJ) + } + } else if this.FieldJ != nil { + return fmt.Errorf("this.FieldJ == nil && that.FieldJ != nil") + } else if that1.FieldJ != nil { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if this.FieldK != nil && that1.FieldK != nil { + if *this.FieldK != *that1.FieldK { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", *this.FieldK, *that1.FieldK) + } + } else if this.FieldK != nil { + return fmt.Errorf("this.FieldK == nil && that.FieldK != nil") + } else if that1.FieldK != nil { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", this.FieldK, that1.FieldK) + } + if this.FielL != nil && that1.FielL != nil { + if *this.FielL != *that1.FielL { + return fmt.Errorf("FielL this(%v) Not Equal that(%v)", *this.FielL, *that1.FielL) + } + } else if this.FielL != nil { + return fmt.Errorf("this.FielL == nil && that.FielL != nil") + } else if that1.FielL != nil { + return fmt.Errorf("FielL this(%v) Not Equal that(%v)", this.FielL, that1.FielL) + } + if this.FieldM != nil && that1.FieldM != nil { + if *this.FieldM != *that1.FieldM { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", *this.FieldM, *that1.FieldM) + } + } else if this.FieldM != nil { + return fmt.Errorf("this.FieldM == nil && that.FieldM != nil") + } else if that1.FieldM != nil { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", this.FieldM, that1.FieldM) + } + if this.FieldN != nil && that1.FieldN != nil { + if *this.FieldN != *that1.FieldN { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", *this.FieldN, *that1.FieldN) + } + } else if this.FieldN != nil { + return fmt.Errorf("this.FieldN == nil && that.FieldN != nil") + } else if that1.FieldN != nil { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", this.FieldN, that1.FieldN) + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", this.FieldO, that1.FieldO) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinOptNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinOptNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if this.FieldC != nil && that1.FieldC != nil { + if *this.FieldC != *that1.FieldC { + return false + } + } else if this.FieldC != nil { + return false + } else if that1.FieldC != nil { + return false + } + if this.FieldD != nil && that1.FieldD != nil { + if *this.FieldD != *that1.FieldD { + return false + } + } else if this.FieldD != nil { + return false + } else if that1.FieldD != nil { + return false + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return false + } + } else if this.FieldE != nil { + return false + } else if that1.FieldE != nil { + return false + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return false + } + } else if this.FieldF != nil { + return false + } else if that1.FieldF != nil { + return false + } + if this.FieldG != nil && that1.FieldG != nil { + if *this.FieldG != *that1.FieldG { + return false + } + } else if this.FieldG != nil { + return false + } else if that1.FieldG != nil { + return false + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return false + } + } else if this.FieldH != nil { + return false + } else if that1.FieldH != nil { + return false + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return false + } + } else if this.FieldI != nil { + return false + } else if that1.FieldI != nil { + return false + } + if this.FieldJ != nil && that1.FieldJ != nil { + if *this.FieldJ != *that1.FieldJ { + return false + } + } else if this.FieldJ != nil { + return false + } else if that1.FieldJ != nil { + return false + } + if this.FieldK != nil && that1.FieldK != nil { + if *this.FieldK != *that1.FieldK { + return false + } + } else if this.FieldK != nil { + return false + } else if that1.FieldK != nil { + return false + } + if this.FielL != nil && that1.FielL != nil { + if *this.FielL != *that1.FielL { + return false + } + } else if this.FielL != nil { + return false + } else if that1.FielL != nil { + return false + } + if this.FieldM != nil && that1.FieldM != nil { + if *this.FieldM != *that1.FieldM { + return false + } + } else if this.FieldM != nil { + return false + } else if that1.FieldM != nil { + return false + } + if this.FieldN != nil && that1.FieldN != nil { + if *this.FieldN != *that1.FieldN { + return false + } + } else if this.FieldN != nil { + return false + } else if that1.FieldN != nil { + return false + } + if !bytes.Equal(this.FieldO, that1.FieldO) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinRepNative) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinRepNative) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinRepNative") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinRepNative but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinRepNativebut is not nil && this == nil") + } + if len(this.FieldA) != len(that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", len(this.FieldA), len(that1.FieldA)) + } + for i := range this.FieldA { + if this.FieldA[i] != that1.FieldA[i] { + return fmt.Errorf("FieldA this[%v](%v) Not Equal that[%v](%v)", i, this.FieldA[i], i, that1.FieldA[i]) + } + } + if len(this.FieldB) != len(that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", len(this.FieldB), len(that1.FieldB)) + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return fmt.Errorf("FieldB this[%v](%v) Not Equal that[%v](%v)", i, this.FieldB[i], i, that1.FieldB[i]) + } + } + if len(this.FieldC) != len(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", len(this.FieldC), len(that1.FieldC)) + } + for i := range this.FieldC { + if this.FieldC[i] != that1.FieldC[i] { + return fmt.Errorf("FieldC this[%v](%v) Not Equal that[%v](%v)", i, this.FieldC[i], i, that1.FieldC[i]) + } + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if this.FieldD[i] != that1.FieldD[i] { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if len(this.FieldE) != len(that1.FieldE) { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", len(this.FieldE), len(that1.FieldE)) + } + for i := range this.FieldE { + if this.FieldE[i] != that1.FieldE[i] { + return fmt.Errorf("FieldE this[%v](%v) Not Equal that[%v](%v)", i, this.FieldE[i], i, that1.FieldE[i]) + } + } + if len(this.FieldF) != len(that1.FieldF) { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", len(this.FieldF), len(that1.FieldF)) + } + for i := range this.FieldF { + if this.FieldF[i] != that1.FieldF[i] { + return fmt.Errorf("FieldF this[%v](%v) Not Equal that[%v](%v)", i, this.FieldF[i], i, that1.FieldF[i]) + } + } + if len(this.FieldG) != len(that1.FieldG) { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", len(this.FieldG), len(that1.FieldG)) + } + for i := range this.FieldG { + if this.FieldG[i] != that1.FieldG[i] { + return fmt.Errorf("FieldG this[%v](%v) Not Equal that[%v](%v)", i, this.FieldG[i], i, that1.FieldG[i]) + } + } + if len(this.FieldH) != len(that1.FieldH) { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", len(this.FieldH), len(that1.FieldH)) + } + for i := range this.FieldH { + if this.FieldH[i] != that1.FieldH[i] { + return fmt.Errorf("FieldH this[%v](%v) Not Equal that[%v](%v)", i, this.FieldH[i], i, that1.FieldH[i]) + } + } + if len(this.FieldI) != len(that1.FieldI) { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", len(this.FieldI), len(that1.FieldI)) + } + for i := range this.FieldI { + if this.FieldI[i] != that1.FieldI[i] { + return fmt.Errorf("FieldI this[%v](%v) Not Equal that[%v](%v)", i, this.FieldI[i], i, that1.FieldI[i]) + } + } + if len(this.FieldJ) != len(that1.FieldJ) { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", len(this.FieldJ), len(that1.FieldJ)) + } + for i := range this.FieldJ { + if this.FieldJ[i] != that1.FieldJ[i] { + return fmt.Errorf("FieldJ this[%v](%v) Not Equal that[%v](%v)", i, this.FieldJ[i], i, that1.FieldJ[i]) + } + } + if len(this.FieldK) != len(that1.FieldK) { + return fmt.Errorf("FieldK this(%v) Not Equal that(%v)", len(this.FieldK), len(that1.FieldK)) + } + for i := range this.FieldK { + if this.FieldK[i] != that1.FieldK[i] { + return fmt.Errorf("FieldK this[%v](%v) Not Equal that[%v](%v)", i, this.FieldK[i], i, that1.FieldK[i]) + } + } + if len(this.FieldL) != len(that1.FieldL) { + return fmt.Errorf("FieldL this(%v) Not Equal that(%v)", len(this.FieldL), len(that1.FieldL)) + } + for i := range this.FieldL { + if this.FieldL[i] != that1.FieldL[i] { + return fmt.Errorf("FieldL this[%v](%v) Not Equal that[%v](%v)", i, this.FieldL[i], i, that1.FieldL[i]) + } + } + if len(this.FieldM) != len(that1.FieldM) { + return fmt.Errorf("FieldM this(%v) Not Equal that(%v)", len(this.FieldM), len(that1.FieldM)) + } + for i := range this.FieldM { + if this.FieldM[i] != that1.FieldM[i] { + return fmt.Errorf("FieldM this[%v](%v) Not Equal that[%v](%v)", i, this.FieldM[i], i, that1.FieldM[i]) + } + } + if len(this.FieldN) != len(that1.FieldN) { + return fmt.Errorf("FieldN this(%v) Not Equal that(%v)", len(this.FieldN), len(that1.FieldN)) + } + for i := range this.FieldN { + if this.FieldN[i] != that1.FieldN[i] { + return fmt.Errorf("FieldN this[%v](%v) Not Equal that[%v](%v)", i, this.FieldN[i], i, that1.FieldN[i]) + } + } + if len(this.FieldO) != len(that1.FieldO) { + return fmt.Errorf("FieldO this(%v) Not Equal that(%v)", len(this.FieldO), len(that1.FieldO)) + } + for i := range this.FieldO { + if !bytes.Equal(this.FieldO[i], that1.FieldO[i]) { + return fmt.Errorf("FieldO this[%v](%v) Not Equal that[%v](%v)", i, this.FieldO[i], i, that1.FieldO[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinRepNative) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinRepNative) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.FieldA) != len(that1.FieldA) { + return false + } + for i := range this.FieldA { + if this.FieldA[i] != that1.FieldA[i] { + return false + } + } + if len(this.FieldB) != len(that1.FieldB) { + return false + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return false + } + } + if len(this.FieldC) != len(that1.FieldC) { + return false + } + for i := range this.FieldC { + if this.FieldC[i] != that1.FieldC[i] { + return false + } + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if this.FieldD[i] != that1.FieldD[i] { + return false + } + } + if len(this.FieldE) != len(that1.FieldE) { + return false + } + for i := range this.FieldE { + if this.FieldE[i] != that1.FieldE[i] { + return false + } + } + if len(this.FieldF) != len(that1.FieldF) { + return false + } + for i := range this.FieldF { + if this.FieldF[i] != that1.FieldF[i] { + return false + } + } + if len(this.FieldG) != len(that1.FieldG) { + return false + } + for i := range this.FieldG { + if this.FieldG[i] != that1.FieldG[i] { + return false + } + } + if len(this.FieldH) != len(that1.FieldH) { + return false + } + for i := range this.FieldH { + if this.FieldH[i] != that1.FieldH[i] { + return false + } + } + if len(this.FieldI) != len(that1.FieldI) { + return false + } + for i := range this.FieldI { + if this.FieldI[i] != that1.FieldI[i] { + return false + } + } + if len(this.FieldJ) != len(that1.FieldJ) { + return false + } + for i := range this.FieldJ { + if this.FieldJ[i] != that1.FieldJ[i] { + return false + } + } + if len(this.FieldK) != len(that1.FieldK) { + return false + } + for i := range this.FieldK { + if this.FieldK[i] != that1.FieldK[i] { + return false + } + } + if len(this.FieldL) != len(that1.FieldL) { + return false + } + for i := range this.FieldL { + if this.FieldL[i] != that1.FieldL[i] { + return false + } + } + if len(this.FieldM) != len(that1.FieldM) { + return false + } + for i := range this.FieldM { + if this.FieldM[i] != that1.FieldM[i] { + return false + } + } + if len(this.FieldN) != len(that1.FieldN) { + return false + } + for i := range this.FieldN { + if this.FieldN[i] != that1.FieldN[i] { + return false + } + } + if len(this.FieldO) != len(that1.FieldO) { + return false + } + for i := range this.FieldO { + if !bytes.Equal(this.FieldO[i], that1.FieldO[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinStruct) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinStruct) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinStruct") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinStruct but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinStructbut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if !this.FieldC.Equal(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", this.FieldC, that1.FieldC) + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", *this.FieldE, *that1.FieldE) + } + } else if this.FieldE != nil { + return fmt.Errorf("this.FieldE == nil && that.FieldE != nil") + } else if that1.FieldE != nil { + return fmt.Errorf("FieldE this(%v) Not Equal that(%v)", this.FieldE, that1.FieldE) + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", *this.FieldF, *that1.FieldF) + } + } else if this.FieldF != nil { + return fmt.Errorf("this.FieldF == nil && that.FieldF != nil") + } else if that1.FieldF != nil { + return fmt.Errorf("FieldF this(%v) Not Equal that(%v)", this.FieldF, that1.FieldF) + } + if !this.FieldG.Equal(that1.FieldG) { + return fmt.Errorf("FieldG this(%v) Not Equal that(%v)", this.FieldG, that1.FieldG) + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", *this.FieldH, *that1.FieldH) + } + } else if this.FieldH != nil { + return fmt.Errorf("this.FieldH == nil && that.FieldH != nil") + } else if that1.FieldH != nil { + return fmt.Errorf("FieldH this(%v) Not Equal that(%v)", this.FieldH, that1.FieldH) + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", *this.FieldI, *that1.FieldI) + } + } else if this.FieldI != nil { + return fmt.Errorf("this.FieldI == nil && that.FieldI != nil") + } else if that1.FieldI != nil { + return fmt.Errorf("FieldI this(%v) Not Equal that(%v)", this.FieldI, that1.FieldI) + } + if !bytes.Equal(this.FieldJ, that1.FieldJ) { + return fmt.Errorf("FieldJ this(%v) Not Equal that(%v)", this.FieldJ, that1.FieldJ) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinStruct) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinStruct) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if !this.FieldC.Equal(that1.FieldC) { + return false + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return false + } + } + if this.FieldE != nil && that1.FieldE != nil { + if *this.FieldE != *that1.FieldE { + return false + } + } else if this.FieldE != nil { + return false + } else if that1.FieldE != nil { + return false + } + if this.FieldF != nil && that1.FieldF != nil { + if *this.FieldF != *that1.FieldF { + return false + } + } else if this.FieldF != nil { + return false + } else if that1.FieldF != nil { + return false + } + if !this.FieldG.Equal(that1.FieldG) { + return false + } + if this.FieldH != nil && that1.FieldH != nil { + if *this.FieldH != *that1.FieldH { + return false + } + } else if this.FieldH != nil { + return false + } else if that1.FieldH != nil { + return false + } + if this.FieldI != nil && that1.FieldI != nil { + if *this.FieldI != *that1.FieldI { + return false + } + } else if this.FieldI != nil { + return false + } else if that1.FieldI != nil { + return false + } + if !bytes.Equal(this.FieldJ, that1.FieldJ) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameCustomType) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameCustomType) + if !ok { + return fmt.Errorf("that is not of type *CustomNameCustomType") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameCustomType but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameCustomTypebut is not nil && this == nil") + } + if that1.FieldA == nil { + if this.FieldA != nil { + return fmt.Errorf("this.FieldA != nil && that1.FieldA == nil") + } + } else if !this.FieldA.Equal(*that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if that1.FieldB == nil { + if this.FieldB != nil { + return fmt.Errorf("this.FieldB != nil && that1.FieldB == nil") + } + } else if !this.FieldB.Equal(*that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if len(this.FieldC) != len(that1.FieldC) { + return fmt.Errorf("FieldC this(%v) Not Equal that(%v)", len(this.FieldC), len(that1.FieldC)) + } + for i := range this.FieldC { + if !this.FieldC[i].Equal(that1.FieldC[i]) { + return fmt.Errorf("FieldC this[%v](%v) Not Equal that[%v](%v)", i, this.FieldC[i], i, that1.FieldC[i]) + } + } + if len(this.FieldD) != len(that1.FieldD) { + return fmt.Errorf("FieldD this(%v) Not Equal that(%v)", len(this.FieldD), len(that1.FieldD)) + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return fmt.Errorf("FieldD this[%v](%v) Not Equal that[%v](%v)", i, this.FieldD[i], i, that1.FieldD[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameCustomType) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameCustomType) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if that1.FieldA == nil { + if this.FieldA != nil { + return false + } + } else if !this.FieldA.Equal(*that1.FieldA) { + return false + } + if that1.FieldB == nil { + if this.FieldB != nil { + return false + } + } else if !this.FieldB.Equal(*that1.FieldB) { + return false + } + if len(this.FieldC) != len(that1.FieldC) { + return false + } + for i := range this.FieldC { + if !this.FieldC[i].Equal(that1.FieldC[i]) { + return false + } + } + if len(this.FieldD) != len(that1.FieldD) { + return false + } + for i := range this.FieldD { + if !this.FieldD[i].Equal(that1.FieldD[i]) { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameNinEmbeddedStructUnion) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameNinEmbeddedStructUnion) + if !ok { + return fmt.Errorf("that is not of type *CustomNameNinEmbeddedStructUnion") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameNinEmbeddedStructUnion but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameNinEmbeddedStructUnionbut is not nil && this == nil") + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return fmt.Errorf("NidOptNative this(%v) Not Equal that(%v)", this.NidOptNative, that1.NidOptNative) + } + if !this.FieldA.Equal(that1.FieldA) { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", *this.FieldB, *that1.FieldB) + } + } else if this.FieldB != nil { + return fmt.Errorf("this.FieldB == nil && that.FieldB != nil") + } else if that1.FieldB != nil { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", this.FieldB, that1.FieldB) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameNinEmbeddedStructUnion) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameNinEmbeddedStructUnion) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.NidOptNative.Equal(that1.NidOptNative) { + return false + } + if !this.FieldA.Equal(that1.FieldA) { + return false + } + if this.FieldB != nil && that1.FieldB != nil { + if *this.FieldB != *that1.FieldB { + return false + } + } else if this.FieldB != nil { + return false + } else if that1.FieldB != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *CustomNameEnum) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*CustomNameEnum) + if !ok { + return fmt.Errorf("that is not of type *CustomNameEnum") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *CustomNameEnum but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *CustomNameEnumbut is not nil && this == nil") + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", *this.FieldA, *that1.FieldA) + } + } else if this.FieldA != nil { + return fmt.Errorf("this.FieldA == nil && that.FieldA != nil") + } else if that1.FieldA != nil { + return fmt.Errorf("FieldA this(%v) Not Equal that(%v)", this.FieldA, that1.FieldA) + } + if len(this.FieldB) != len(that1.FieldB) { + return fmt.Errorf("FieldB this(%v) Not Equal that(%v)", len(this.FieldB), len(that1.FieldB)) + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return fmt.Errorf("FieldB this[%v](%v) Not Equal that[%v](%v)", i, this.FieldB[i], i, that1.FieldB[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *CustomNameEnum) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*CustomNameEnum) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.FieldA != nil && that1.FieldA != nil { + if *this.FieldA != *that1.FieldA { + return false + } + } else if this.FieldA != nil { + return false + } else if that1.FieldA != nil { + return false + } + if len(this.FieldB) != len(that1.FieldB) { + return false + } + for i := range this.FieldB { + if this.FieldB[i] != that1.FieldB[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NoExtensionsMap) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NoExtensionsMap) + if !ok { + return fmt.Errorf("that is not of type *NoExtensionsMap") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NoExtensionsMap but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NoExtensionsMapbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) { + return fmt.Errorf("XXX_extensions this(%v) Not Equal that(%v)", this.XXX_extensions, that1.XXX_extensions) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NoExtensionsMap) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NoExtensionsMap) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_extensions, that1.XXX_extensions) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Unrecognized) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Unrecognized) + if !ok { + return fmt.Errorf("that is not of type *Unrecognized") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Unrecognized but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Unrecognizedbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *Unrecognized) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Unrecognized) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} +func (this *UnrecognizedWithInner) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithInner) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithInner") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithInner but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithInnerbut is not nil && this == nil") + } + if len(this.Embedded) != len(that1.Embedded) { + return fmt.Errorf("Embedded this(%v) Not Equal that(%v)", len(this.Embedded), len(that1.Embedded)) + } + for i := range this.Embedded { + if !this.Embedded[i].Equal(that1.Embedded[i]) { + return fmt.Errorf("Embedded this[%v](%v) Not Equal that[%v](%v)", i, this.Embedded[i], i, that1.Embedded[i]) + } + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *UnrecognizedWithInner) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithInner) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Embedded) != len(that1.Embedded) { + return false + } + for i := range this.Embedded { + if !this.Embedded[i].Equal(that1.Embedded[i]) { + return false + } + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *UnrecognizedWithInner_Inner) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithInner_Inner) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithInner_Inner") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithInner_Inner but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithInner_Innerbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *UnrecognizedWithInner_Inner) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithInner_Inner) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} +func (this *UnrecognizedWithEmbed) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithEmbed) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithEmbed") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithEmbed but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithEmbedbut is not nil && this == nil") + } + if !this.UnrecognizedWithEmbed_Embedded.Equal(&that1.UnrecognizedWithEmbed_Embedded) { + return fmt.Errorf("UnrecognizedWithEmbed_Embedded this(%v) Not Equal that(%v)", this.UnrecognizedWithEmbed_Embedded, that1.UnrecognizedWithEmbed_Embedded) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *UnrecognizedWithEmbed) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithEmbed) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.UnrecognizedWithEmbed_Embedded.Equal(&that1.UnrecognizedWithEmbed_Embedded) { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *UnrecognizedWithEmbed_Embedded) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnrecognizedWithEmbed_Embedded) + if !ok { + return fmt.Errorf("that is not of type *UnrecognizedWithEmbed_Embedded") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnrecognizedWithEmbed_Embedded but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnrecognizedWithEmbed_Embeddedbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + return nil +} +func (this *UnrecognizedWithEmbed_Embedded) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnrecognizedWithEmbed_Embedded) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + return true +} + +type NidOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() float64 + GetField2() float32 + GetField3() int32 + GetField4() int64 + GetField5() uint32 + GetField6() uint64 + GetField7() int32 + GetField8() int64 + GetField9() uint32 + GetField10() int32 + GetField11() uint64 + GetField12() int64 + GetField13() bool + GetField14() string + GetField15() []byte +} + +func (this *NidOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptNativeFromFace(this) +} + +func (this *NidOptNative) GetField1() float64 { + return this.Field1 +} + +func (this *NidOptNative) GetField2() float32 { + return this.Field2 +} + +func (this *NidOptNative) GetField3() int32 { + return this.Field3 +} + +func (this *NidOptNative) GetField4() int64 { + return this.Field4 +} + +func (this *NidOptNative) GetField5() uint32 { + return this.Field5 +} + +func (this *NidOptNative) GetField6() uint64 { + return this.Field6 +} + +func (this *NidOptNative) GetField7() int32 { + return this.Field7 +} + +func (this *NidOptNative) GetField8() int64 { + return this.Field8 +} + +func (this *NidOptNative) GetField9() uint32 { + return this.Field9 +} + +func (this *NidOptNative) GetField10() int32 { + return this.Field10 +} + +func (this *NidOptNative) GetField11() uint64 { + return this.Field11 +} + +func (this *NidOptNative) GetField12() int64 { + return this.Field12 +} + +func (this *NidOptNative) GetField13() bool { + return this.Field13 +} + +func (this *NidOptNative) GetField14() string { + return this.Field14 +} + +func (this *NidOptNative) GetField15() []byte { + return this.Field15 +} + +func NewNidOptNativeFromFace(that NidOptNativeFace) *NidOptNative { + this := &NidOptNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *int32 + GetField4() *int64 + GetField5() *uint32 + GetField6() *uint64 + GetField7() *int32 + GetField8() *int64 + GetField9() *uint32 + GetField10() *int32 + GetField11() *uint64 + GetField12() *int64 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptNativeFromFace(this) +} + +func (this *NinOptNative) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptNative) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptNative) GetField3() *int32 { + return this.Field3 +} + +func (this *NinOptNative) GetField4() *int64 { + return this.Field4 +} + +func (this *NinOptNative) GetField5() *uint32 { + return this.Field5 +} + +func (this *NinOptNative) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptNative) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptNative) GetField8() *int64 { + return this.Field8 +} + +func (this *NinOptNative) GetField9() *uint32 { + return this.Field9 +} + +func (this *NinOptNative) GetField10() *int32 { + return this.Field10 +} + +func (this *NinOptNative) GetField11() *uint64 { + return this.Field11 +} + +func (this *NinOptNative) GetField12() *int64 { + return this.Field12 +} + +func (this *NinOptNative) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptNative) GetField14() *string { + return this.Field14 +} + +func (this *NinOptNative) GetField15() []byte { + return this.Field15 +} + +func NewNinOptNativeFromFace(that NinOptNativeFace) *NinOptNative { + this := &NinOptNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NidRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepNativeFromFace(this) +} + +func (this *NidRepNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NidRepNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NidRepNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NidRepNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NidRepNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NidRepNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NidRepNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NidRepNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NidRepNative) GetField13() []bool { + return this.Field13 +} + +func (this *NidRepNative) GetField14() []string { + return this.Field14 +} + +func (this *NidRepNative) GetField15() [][]byte { + return this.Field15 +} + +func NewNidRepNativeFromFace(that NidRepNativeFace) *NidRepNative { + this := &NidRepNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NinRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepNativeFromFace(this) +} + +func (this *NinRepNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NinRepNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NinRepNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NinRepNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NinRepNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NinRepNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NinRepNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NinRepNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NinRepNative) GetField13() []bool { + return this.Field13 +} + +func (this *NinRepNative) GetField14() []string { + return this.Field14 +} + +func (this *NinRepNative) GetField15() [][]byte { + return this.Field15 +} + +func NewNinRepNativeFromFace(that NinRepNativeFace) *NinRepNative { + this := &NinRepNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepPackedNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool +} + +func (this *NidRepPackedNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepPackedNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepPackedNativeFromFace(this) +} + +func (this *NidRepPackedNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepPackedNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepPackedNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NidRepPackedNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NidRepPackedNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NidRepPackedNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepPackedNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepPackedNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NidRepPackedNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NidRepPackedNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NidRepPackedNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NidRepPackedNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NidRepPackedNative) GetField13() []bool { + return this.Field13 +} + +func NewNidRepPackedNativeFromFace(that NidRepPackedNativeFace) *NidRepPackedNative { + this := &NidRepPackedNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + return this +} + +type NinRepPackedNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []int32 + GetField4() []int64 + GetField5() []uint32 + GetField6() []uint64 + GetField7() []int32 + GetField8() []int64 + GetField9() []uint32 + GetField10() []int32 + GetField11() []uint64 + GetField12() []int64 + GetField13() []bool +} + +func (this *NinRepPackedNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepPackedNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepPackedNativeFromFace(this) +} + +func (this *NinRepPackedNative) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepPackedNative) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepPackedNative) GetField3() []int32 { + return this.Field3 +} + +func (this *NinRepPackedNative) GetField4() []int64 { + return this.Field4 +} + +func (this *NinRepPackedNative) GetField5() []uint32 { + return this.Field5 +} + +func (this *NinRepPackedNative) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepPackedNative) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepPackedNative) GetField8() []int64 { + return this.Field8 +} + +func (this *NinRepPackedNative) GetField9() []uint32 { + return this.Field9 +} + +func (this *NinRepPackedNative) GetField10() []int32 { + return this.Field10 +} + +func (this *NinRepPackedNative) GetField11() []uint64 { + return this.Field11 +} + +func (this *NinRepPackedNative) GetField12() []int64 { + return this.Field12 +} + +func (this *NinRepPackedNative) GetField13() []bool { + return this.Field13 +} + +func NewNinRepPackedNativeFromFace(that NinRepPackedNativeFace) *NinRepPackedNative { + this := &NinRepPackedNative{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field9 = that.GetField9() + this.Field10 = that.GetField10() + this.Field11 = that.GetField11() + this.Field12 = that.GetField12() + this.Field13 = that.GetField13() + return this +} + +type NidOptStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() float64 + GetField2() float32 + GetField3() NidOptNative + GetField4() NinOptNative + GetField6() uint64 + GetField7() int32 + GetField8() NidOptNative + GetField13() bool + GetField14() string + GetField15() []byte +} + +func (this *NidOptStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptStructFromFace(this) +} + +func (this *NidOptStruct) GetField1() float64 { + return this.Field1 +} + +func (this *NidOptStruct) GetField2() float32 { + return this.Field2 +} + +func (this *NidOptStruct) GetField3() NidOptNative { + return this.Field3 +} + +func (this *NidOptStruct) GetField4() NinOptNative { + return this.Field4 +} + +func (this *NidOptStruct) GetField6() uint64 { + return this.Field6 +} + +func (this *NidOptStruct) GetField7() int32 { + return this.Field7 +} + +func (this *NidOptStruct) GetField8() NidOptNative { + return this.Field8 +} + +func (this *NidOptStruct) GetField13() bool { + return this.Field13 +} + +func (this *NidOptStruct) GetField14() string { + return this.Field14 +} + +func (this *NidOptStruct) GetField15() []byte { + return this.Field15 +} + +func NewNidOptStructFromFace(that NidOptStructFace) *NidOptStruct { + this := &NidOptStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *NidOptNative + GetField4() *NinOptNative + GetField6() *uint64 + GetField7() *int32 + GetField8() *NidOptNative + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptStructFromFace(this) +} + +func (this *NinOptStruct) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptStruct) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptStruct) GetField3() *NidOptNative { + return this.Field3 +} + +func (this *NinOptStruct) GetField4() *NinOptNative { + return this.Field4 +} + +func (this *NinOptStruct) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptStruct) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptStruct) GetField8() *NidOptNative { + return this.Field8 +} + +func (this *NinOptStruct) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptStruct) GetField14() *string { + return this.Field14 +} + +func (this *NinOptStruct) GetField15() []byte { + return this.Field15 +} + +func NewNinOptStructFromFace(that NinOptStructFace) *NinOptStruct { + this := &NinOptStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidRepStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []NidOptNative + GetField4() []NinOptNative + GetField6() []uint64 + GetField7() []int32 + GetField8() []NidOptNative + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NidRepStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepStructFromFace(this) +} + +func (this *NidRepStruct) GetField1() []float64 { + return this.Field1 +} + +func (this *NidRepStruct) GetField2() []float32 { + return this.Field2 +} + +func (this *NidRepStruct) GetField3() []NidOptNative { + return this.Field3 +} + +func (this *NidRepStruct) GetField4() []NinOptNative { + return this.Field4 +} + +func (this *NidRepStruct) GetField6() []uint64 { + return this.Field6 +} + +func (this *NidRepStruct) GetField7() []int32 { + return this.Field7 +} + +func (this *NidRepStruct) GetField8() []NidOptNative { + return this.Field8 +} + +func (this *NidRepStruct) GetField13() []bool { + return this.Field13 +} + +func (this *NidRepStruct) GetField14() []string { + return this.Field14 +} + +func (this *NidRepStruct) GetField15() [][]byte { + return this.Field15 +} + +func NewNidRepStructFromFace(that NidRepStructFace) *NidRepStruct { + this := &NidRepStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinRepStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []float64 + GetField2() []float32 + GetField3() []*NidOptNative + GetField4() []*NinOptNative + GetField6() []uint64 + GetField7() []int32 + GetField8() []*NidOptNative + GetField13() []bool + GetField14() []string + GetField15() [][]byte +} + +func (this *NinRepStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepStructFromFace(this) +} + +func (this *NinRepStruct) GetField1() []float64 { + return this.Field1 +} + +func (this *NinRepStruct) GetField2() []float32 { + return this.Field2 +} + +func (this *NinRepStruct) GetField3() []*NidOptNative { + return this.Field3 +} + +func (this *NinRepStruct) GetField4() []*NinOptNative { + return this.Field4 +} + +func (this *NinRepStruct) GetField6() []uint64 { + return this.Field6 +} + +func (this *NinRepStruct) GetField7() []int32 { + return this.Field7 +} + +func (this *NinRepStruct) GetField8() []*NidOptNative { + return this.Field8 +} + +func (this *NinRepStruct) GetField13() []bool { + return this.Field13 +} + +func (this *NinRepStruct) GetField14() []string { + return this.Field14 +} + +func (this *NinRepStruct) GetField15() [][]byte { + return this.Field15 +} + +func NewNinRepStructFromFace(that NinRepStructFace) *NinRepStruct { + this := &NinRepStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field8 = that.GetField8() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NidEmbeddedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() NidOptNative + GetField210() bool +} + +func (this *NidEmbeddedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidEmbeddedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidEmbeddedStructFromFace(this) +} + +func (this *NidEmbeddedStruct) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NidEmbeddedStruct) GetField200() NidOptNative { + return this.Field200 +} + +func (this *NidEmbeddedStruct) GetField210() bool { + return this.Field210 +} + +func NewNidEmbeddedStructFromFace(that NidEmbeddedStructFace) *NidEmbeddedStruct { + this := &NidEmbeddedStruct{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NinEmbeddedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() *NidOptNative + GetField210() *bool +} + +func (this *NinEmbeddedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinEmbeddedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinEmbeddedStructFromFace(this) +} + +func (this *NinEmbeddedStruct) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NinEmbeddedStruct) GetField200() *NidOptNative { + return this.Field200 +} + +func (this *NinEmbeddedStruct) GetField210() *bool { + return this.Field210 +} + +func NewNinEmbeddedStructFromFace(that NinEmbeddedStructFace) *NinEmbeddedStruct { + this := &NinEmbeddedStruct{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NidNestedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() NidOptStruct + GetField2() []NidRepStruct +} + +func (this *NidNestedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidNestedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidNestedStructFromFace(this) +} + +func (this *NidNestedStruct) GetField1() NidOptStruct { + return this.Field1 +} + +func (this *NidNestedStruct) GetField2() []NidRepStruct { + return this.Field2 +} + +func NewNidNestedStructFromFace(that NidNestedStructFace) *NidNestedStruct { + this := &NidNestedStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + return this +} + +type NinNestedStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *NinOptStruct + GetField2() []*NinRepStruct +} + +func (this *NinNestedStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinNestedStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinNestedStructFromFace(this) +} + +func (this *NinNestedStruct) GetField1() *NinOptStruct { + return this.Field1 +} + +func (this *NinNestedStruct) GetField2() []*NinRepStruct { + return this.Field2 +} + +func NewNinNestedStructFromFace(that NinNestedStructFace) *NinNestedStruct { + this := &NinNestedStruct{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + return this +} + +type NidOptCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() Uuid + GetValue() github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NidOptCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptCustomFromFace(this) +} + +func (this *NidOptCustom) GetId() Uuid { + return this.Id +} + +func (this *NidOptCustom) GetValue() github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNidOptCustomFromFace(that NidOptCustomFace) *NidOptCustom { + this := &NidOptCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type CustomDashFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetValue() *github_com_gogo_protobuf_test_custom_dash_type.Bytes +} + +func (this *CustomDash) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomDash) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomDashFromFace(this) +} + +func (this *CustomDash) GetValue() *github_com_gogo_protobuf_test_custom_dash_type.Bytes { + return this.Value +} + +func NewCustomDashFromFace(that CustomDashFace) *CustomDash { + this := &CustomDash{} + this.Value = that.GetValue() + return this +} + +type NinOptCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() *Uuid + GetValue() *github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NinOptCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptCustomFromFace(this) +} + +func (this *NinOptCustom) GetId() *Uuid { + return this.Id +} + +func (this *NinOptCustom) GetValue() *github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNinOptCustomFromFace(that NinOptCustomFace) *NinOptCustom { + this := &NinOptCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NidRepCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() []Uuid + GetValue() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NidRepCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepCustomFromFace(this) +} + +func (this *NidRepCustom) GetId() []Uuid { + return this.Id +} + +func (this *NidRepCustom) GetValue() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNidRepCustomFromFace(that NidRepCustomFace) *NidRepCustom { + this := &NidRepCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NinRepCustomFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetId() []Uuid + GetValue() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *NinRepCustom) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepCustom) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepCustomFromFace(this) +} + +func (this *NinRepCustom) GetId() []Uuid { + return this.Id +} + +func (this *NinRepCustom) GetValue() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.Value +} + +func NewNinRepCustomFromFace(that NinRepCustomFace) *NinRepCustom { + this := &NinRepCustom{} + this.Id = that.GetId() + this.Value = that.GetValue() + return this +} + +type NinOptNativeUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *int32 + GetField4() *int64 + GetField5() *uint32 + GetField6() *uint64 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptNativeUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptNativeUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptNativeUnionFromFace(this) +} + +func (this *NinOptNativeUnion) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptNativeUnion) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptNativeUnion) GetField3() *int32 { + return this.Field3 +} + +func (this *NinOptNativeUnion) GetField4() *int64 { + return this.Field4 +} + +func (this *NinOptNativeUnion) GetField5() *uint32 { + return this.Field5 +} + +func (this *NinOptNativeUnion) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptNativeUnion) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptNativeUnion) GetField14() *string { + return this.Field14 +} + +func (this *NinOptNativeUnion) GetField15() []byte { + return this.Field15 +} + +func NewNinOptNativeUnionFromFace(that NinOptNativeUnionFace) *NinOptNativeUnion { + this := &NinOptNativeUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field5 = that.GetField5() + this.Field6 = that.GetField6() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinOptStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *float64 + GetField2() *float32 + GetField3() *NidOptNative + GetField4() *NinOptNative + GetField6() *uint64 + GetField7() *int32 + GetField13() *bool + GetField14() *string + GetField15() []byte +} + +func (this *NinOptStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptStructUnionFromFace(this) +} + +func (this *NinOptStructUnion) GetField1() *float64 { + return this.Field1 +} + +func (this *NinOptStructUnion) GetField2() *float32 { + return this.Field2 +} + +func (this *NinOptStructUnion) GetField3() *NidOptNative { + return this.Field3 +} + +func (this *NinOptStructUnion) GetField4() *NinOptNative { + return this.Field4 +} + +func (this *NinOptStructUnion) GetField6() *uint64 { + return this.Field6 +} + +func (this *NinOptStructUnion) GetField7() *int32 { + return this.Field7 +} + +func (this *NinOptStructUnion) GetField13() *bool { + return this.Field13 +} + +func (this *NinOptStructUnion) GetField14() *string { + return this.Field14 +} + +func (this *NinOptStructUnion) GetField15() []byte { + return this.Field15 +} + +func NewNinOptStructUnionFromFace(that NinOptStructUnionFace) *NinOptStructUnion { + this := &NinOptStructUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + this.Field4 = that.GetField4() + this.Field6 = that.GetField6() + this.Field7 = that.GetField7() + this.Field13 = that.GetField13() + this.Field14 = that.GetField14() + this.Field15 = that.GetField15() + return this +} + +type NinEmbeddedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetField200() *NinOptNative + GetField210() *bool +} + +func (this *NinEmbeddedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinEmbeddedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinEmbeddedStructUnionFromFace(this) +} + +func (this *NinEmbeddedStructUnion) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *NinEmbeddedStructUnion) GetField200() *NinOptNative { + return this.Field200 +} + +func (this *NinEmbeddedStructUnion) GetField210() *bool { + return this.Field210 +} + +func NewNinEmbeddedStructUnionFromFace(that NinEmbeddedStructUnionFace) *NinEmbeddedStructUnion { + this := &NinEmbeddedStructUnion{} + this.NidOptNative = that.GetNidOptNative() + this.Field200 = that.GetField200() + this.Field210 = that.GetField210() + return this +} + +type NinNestedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *NinOptNativeUnion + GetField2() *NinOptStructUnion + GetField3() *NinEmbeddedStructUnion +} + +func (this *NinNestedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinNestedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinNestedStructUnionFromFace(this) +} + +func (this *NinNestedStructUnion) GetField1() *NinOptNativeUnion { + return this.Field1 +} + +func (this *NinNestedStructUnion) GetField2() *NinOptStructUnion { + return this.Field2 +} + +func (this *NinNestedStructUnion) GetField3() *NinEmbeddedStructUnion { + return this.Field3 +} + +func NewNinNestedStructUnionFromFace(that NinNestedStructUnionFace) *NinNestedStructUnion { + this := &NinNestedStructUnion{} + this.Field1 = that.GetField1() + this.Field2 = that.GetField2() + this.Field3 = that.GetField3() + return this +} + +type TreeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetOr() *OrBranch + GetAnd() *AndBranch + GetLeaf() *Leaf +} + +func (this *Tree) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Tree) TestProto() github_com_gogo_protobuf_proto.Message { + return NewTreeFromFace(this) +} + +func (this *Tree) GetOr() *OrBranch { + return this.Or +} + +func (this *Tree) GetAnd() *AndBranch { + return this.And +} + +func (this *Tree) GetLeaf() *Leaf { + return this.Leaf +} + +func NewTreeFromFace(that TreeFace) *Tree { + this := &Tree{} + this.Or = that.GetOr() + this.And = that.GetAnd() + this.Leaf = that.GetLeaf() + return this +} + +type OrBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() Tree + GetRight() Tree +} + +func (this *OrBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *OrBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewOrBranchFromFace(this) +} + +func (this *OrBranch) GetLeft() Tree { + return this.Left +} + +func (this *OrBranch) GetRight() Tree { + return this.Right +} + +func NewOrBranchFromFace(that OrBranchFace) *OrBranch { + this := &OrBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type AndBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() Tree + GetRight() Tree +} + +func (this *AndBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AndBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAndBranchFromFace(this) +} + +func (this *AndBranch) GetLeft() Tree { + return this.Left +} + +func (this *AndBranch) GetRight() Tree { + return this.Right +} + +func NewAndBranchFromFace(that AndBranchFace) *AndBranch { + this := &AndBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type LeafFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetValue() int64 + GetStrValue() string +} + +func (this *Leaf) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Leaf) TestProto() github_com_gogo_protobuf_proto.Message { + return NewLeafFromFace(this) +} + +func (this *Leaf) GetValue() int64 { + return this.Value +} + +func (this *Leaf) GetStrValue() string { + return this.StrValue +} + +func NewLeafFromFace(that LeafFace) *Leaf { + this := &Leaf{} + this.Value = that.GetValue() + this.StrValue = that.GetStrValue() + return this +} + +type DeepTreeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetDown() *ADeepBranch + GetAnd() *AndDeepBranch + GetLeaf() *DeepLeaf +} + +func (this *DeepTree) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *DeepTree) TestProto() github_com_gogo_protobuf_proto.Message { + return NewDeepTreeFromFace(this) +} + +func (this *DeepTree) GetDown() *ADeepBranch { + return this.Down +} + +func (this *DeepTree) GetAnd() *AndDeepBranch { + return this.And +} + +func (this *DeepTree) GetLeaf() *DeepLeaf { + return this.Leaf +} + +func NewDeepTreeFromFace(that DeepTreeFace) *DeepTree { + this := &DeepTree{} + this.Down = that.GetDown() + this.And = that.GetAnd() + this.Leaf = that.GetLeaf() + return this +} + +type ADeepBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetDown() DeepTree +} + +func (this *ADeepBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *ADeepBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewADeepBranchFromFace(this) +} + +func (this *ADeepBranch) GetDown() DeepTree { + return this.Down +} + +func NewADeepBranchFromFace(that ADeepBranchFace) *ADeepBranch { + this := &ADeepBranch{} + this.Down = that.GetDown() + return this +} + +type AndDeepBranchFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetLeft() DeepTree + GetRight() DeepTree +} + +func (this *AndDeepBranch) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AndDeepBranch) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAndDeepBranchFromFace(this) +} + +func (this *AndDeepBranch) GetLeft() DeepTree { + return this.Left +} + +func (this *AndDeepBranch) GetRight() DeepTree { + return this.Right +} + +func NewAndDeepBranchFromFace(that AndDeepBranchFace) *AndDeepBranch { + this := &AndDeepBranch{} + this.Left = that.GetLeft() + this.Right = that.GetRight() + return this +} + +type DeepLeafFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetTree() Tree +} + +func (this *DeepLeaf) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *DeepLeaf) TestProto() github_com_gogo_protobuf_proto.Message { + return NewDeepLeafFromFace(this) +} + +func (this *DeepLeaf) GetTree() Tree { + return this.Tree +} + +func NewDeepLeafFromFace(that DeepLeafFace) *DeepLeaf { + this := &DeepLeaf{} + this.Tree = that.GetTree() + return this +} + +type NilFace interface { + Proto() github_com_gogo_protobuf_proto.Message +} + +func (this *Nil) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Nil) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNilFromFace(this) +} + +func NewNilFromFace(that NilFace) *Nil { + this := &Nil{} + return this +} + +type NidOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() TheTestEnum +} + +func (this *NidOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidOptEnumFromFace(this) +} + +func (this *NidOptEnum) GetField1() TheTestEnum { + return this.Field1 +} + +func NewNidOptEnumFromFace(that NidOptEnumFace) *NidOptEnum { + this := &NidOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type NinOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *TheTestEnum +} + +func (this *NinOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinOptEnumFromFace(this) +} + +func (this *NinOptEnum) GetField1() *TheTestEnum { + return this.Field1 +} + +func NewNinOptEnumFromFace(that NinOptEnumFace) *NinOptEnum { + this := &NinOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type NidRepEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []TheTestEnum +} + +func (this *NidRepEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NidRepEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNidRepEnumFromFace(this) +} + +func (this *NidRepEnum) GetField1() []TheTestEnum { + return this.Field1 +} + +func NewNidRepEnumFromFace(that NidRepEnumFace) *NidRepEnum { + this := &NidRepEnum{} + this.Field1 = that.GetField1() + return this +} + +type NinRepEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() []TheTestEnum +} + +func (this *NinRepEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NinRepEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNinRepEnumFromFace(this) +} + +func (this *NinRepEnum) GetField1() []TheTestEnum { + return this.Field1 +} + +func NewNinRepEnumFromFace(that NinRepEnumFace) *NinRepEnum { + this := &NinRepEnum{} + this.Field1 = that.GetField1() + return this +} + +type AnotherNinOptEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *AnotherTestEnum +} + +func (this *AnotherNinOptEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *AnotherNinOptEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewAnotherNinOptEnumFromFace(this) +} + +func (this *AnotherNinOptEnum) GetField1() *AnotherTestEnum { + return this.Field1 +} + +func NewAnotherNinOptEnumFromFace(that AnotherNinOptEnumFace) *AnotherNinOptEnum { + this := &AnotherNinOptEnum{} + this.Field1 = that.GetField1() + return this +} + +type TimerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetTime1() int64 + GetTime2() int64 + GetData() []byte +} + +func (this *Timer) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Timer) TestProto() github_com_gogo_protobuf_proto.Message { + return NewTimerFromFace(this) +} + +func (this *Timer) GetTime1() int64 { + return this.Time1 +} + +func (this *Timer) GetTime2() int64 { + return this.Time2 +} + +func (this *Timer) GetData() []byte { + return this.Data +} + +func NewTimerFromFace(that TimerFace) *Timer { + this := &Timer{} + this.Time1 = that.GetTime1() + this.Time2 = that.GetTime2() + this.Data = that.GetData() + return this +} + +type NestedDefinitionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *int64 + GetEnumField() *NestedDefinition_NestedEnum + GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg + GetNM() *NestedDefinition_NestedMessage +} + +func (this *NestedDefinition) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinitionFromFace(this) +} + +func (this *NestedDefinition) GetField1() *int64 { + return this.Field1 +} + +func (this *NestedDefinition) GetEnumField() *NestedDefinition_NestedEnum { + return this.EnumField +} + +func (this *NestedDefinition) GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.NNM +} + +func (this *NestedDefinition) GetNM() *NestedDefinition_NestedMessage { + return this.NM +} + +func NewNestedDefinitionFromFace(that NestedDefinitionFace) *NestedDefinition { + this := &NestedDefinition{} + this.Field1 = that.GetField1() + this.EnumField = that.GetEnumField() + this.NNM = that.GetNNM() + this.NM = that.GetNM() + return this +} + +type NestedDefinition_NestedMessageFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNestedField1() *uint64 + GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg +} + +func (this *NestedDefinition_NestedMessage) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition_NestedMessage) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinition_NestedMessageFromFace(this) +} + +func (this *NestedDefinition_NestedMessage) GetNestedField1() *uint64 { + return this.NestedField1 +} + +func (this *NestedDefinition_NestedMessage) GetNNM() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.NNM +} + +func NewNestedDefinition_NestedMessageFromFace(that NestedDefinition_NestedMessageFace) *NestedDefinition_NestedMessage { + this := &NestedDefinition_NestedMessage{} + this.NestedField1 = that.GetNestedField1() + this.NNM = that.GetNNM() + return this +} + +type NestedDefinition_NestedMessage_NestedNestedMsgFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNestedNestedField1() *string +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedDefinition_NestedMessage_NestedNestedMsgFromFace(this) +} + +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) GetNestedNestedField1() *string { + return this.NestedNestedField1 +} + +func NewNestedDefinition_NestedMessage_NestedNestedMsgFromFace(that NestedDefinition_NestedMessage_NestedNestedMsgFace) *NestedDefinition_NestedMessage_NestedNestedMsg { + this := &NestedDefinition_NestedMessage_NestedNestedMsg{} + this.NestedNestedField1 = that.GetNestedNestedField1() + return this +} + +type NestedScopeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetA() *NestedDefinition_NestedMessage_NestedNestedMsg + GetB() *NestedDefinition_NestedEnum + GetC() *NestedDefinition_NestedMessage +} + +func (this *NestedScope) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *NestedScope) TestProto() github_com_gogo_protobuf_proto.Message { + return NewNestedScopeFromFace(this) +} + +func (this *NestedScope) GetA() *NestedDefinition_NestedMessage_NestedNestedMsg { + return this.A +} + +func (this *NestedScope) GetB() *NestedDefinition_NestedEnum { + return this.B +} + +func (this *NestedScope) GetC() *NestedDefinition_NestedMessage { + return this.C +} + +func NewNestedScopeFromFace(that NestedScopeFace) *NestedScope { + this := &NestedScope{} + this.A = that.GetA() + this.B = that.GetB() + this.C = that.GetC() + return this +} + +type CustomContainerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetCustomStruct() NidOptCustom +} + +func (this *CustomContainer) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomContainer) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomContainerFromFace(this) +} + +func (this *CustomContainer) GetCustomStruct() NidOptCustom { + return this.CustomStruct +} + +func NewCustomContainerFromFace(that CustomContainerFace) *CustomContainer { + this := &CustomContainer{} + this.CustomStruct = that.GetCustomStruct() + return this +} + +type CustomNameNidOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() float64 + GetFieldB() float32 + GetFieldC() int32 + GetFieldD() int64 + GetFieldE() uint32 + GetFieldF() uint64 + GetFieldG() int32 + GetFieldH() int64 + GetFieldI() uint32 + GetFieldJ() int32 + GetFieldK() uint64 + GetFieldL() int64 + GetFieldM() bool + GetFieldN() string + GetFieldO() []byte +} + +func (this *CustomNameNidOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNidOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNidOptNativeFromFace(this) +} + +func (this *CustomNameNidOptNative) GetFieldA() float64 { + return this.FieldA +} + +func (this *CustomNameNidOptNative) GetFieldB() float32 { + return this.FieldB +} + +func (this *CustomNameNidOptNative) GetFieldC() int32 { + return this.FieldC +} + +func (this *CustomNameNidOptNative) GetFieldD() int64 { + return this.FieldD +} + +func (this *CustomNameNidOptNative) GetFieldE() uint32 { + return this.FieldE +} + +func (this *CustomNameNidOptNative) GetFieldF() uint64 { + return this.FieldF +} + +func (this *CustomNameNidOptNative) GetFieldG() int32 { + return this.FieldG +} + +func (this *CustomNameNidOptNative) GetFieldH() int64 { + return this.FieldH +} + +func (this *CustomNameNidOptNative) GetFieldI() uint32 { + return this.FieldI +} + +func (this *CustomNameNidOptNative) GetFieldJ() int32 { + return this.FieldJ +} + +func (this *CustomNameNidOptNative) GetFieldK() uint64 { + return this.FieldK +} + +func (this *CustomNameNidOptNative) GetFieldL() int64 { + return this.FieldL +} + +func (this *CustomNameNidOptNative) GetFieldM() bool { + return this.FieldM +} + +func (this *CustomNameNidOptNative) GetFieldN() string { + return this.FieldN +} + +func (this *CustomNameNidOptNative) GetFieldO() []byte { + return this.FieldO +} + +func NewCustomNameNidOptNativeFromFace(that CustomNameNidOptNativeFace) *CustomNameNidOptNative { + this := &CustomNameNidOptNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FieldL = that.GetFieldL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinOptNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *float64 + GetFieldB() *float32 + GetFieldC() *int32 + GetFieldD() *int64 + GetFieldE() *uint32 + GetFieldF() *uint64 + GetFieldG() *int32 + GetFieldH() *int64 + GetFieldI() *uint32 + GetFieldJ() *int32 + GetFieldK() *uint64 + GetFielL() *int64 + GetFieldM() *bool + GetFieldN() *string + GetFieldO() []byte +} + +func (this *CustomNameNinOptNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinOptNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinOptNativeFromFace(this) +} + +func (this *CustomNameNinOptNative) GetFieldA() *float64 { + return this.FieldA +} + +func (this *CustomNameNinOptNative) GetFieldB() *float32 { + return this.FieldB +} + +func (this *CustomNameNinOptNative) GetFieldC() *int32 { + return this.FieldC +} + +func (this *CustomNameNinOptNative) GetFieldD() *int64 { + return this.FieldD +} + +func (this *CustomNameNinOptNative) GetFieldE() *uint32 { + return this.FieldE +} + +func (this *CustomNameNinOptNative) GetFieldF() *uint64 { + return this.FieldF +} + +func (this *CustomNameNinOptNative) GetFieldG() *int32 { + return this.FieldG +} + +func (this *CustomNameNinOptNative) GetFieldH() *int64 { + return this.FieldH +} + +func (this *CustomNameNinOptNative) GetFieldI() *uint32 { + return this.FieldI +} + +func (this *CustomNameNinOptNative) GetFieldJ() *int32 { + return this.FieldJ +} + +func (this *CustomNameNinOptNative) GetFieldK() *uint64 { + return this.FieldK +} + +func (this *CustomNameNinOptNative) GetFielL() *int64 { + return this.FielL +} + +func (this *CustomNameNinOptNative) GetFieldM() *bool { + return this.FieldM +} + +func (this *CustomNameNinOptNative) GetFieldN() *string { + return this.FieldN +} + +func (this *CustomNameNinOptNative) GetFieldO() []byte { + return this.FieldO +} + +func NewCustomNameNinOptNativeFromFace(that CustomNameNinOptNativeFace) *CustomNameNinOptNative { + this := &CustomNameNinOptNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FielL = that.GetFielL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinRepNativeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() []float64 + GetFieldB() []float32 + GetFieldC() []int32 + GetFieldD() []int64 + GetFieldE() []uint32 + GetFieldF() []uint64 + GetFieldG() []int32 + GetFieldH() []int64 + GetFieldI() []uint32 + GetFieldJ() []int32 + GetFieldK() []uint64 + GetFieldL() []int64 + GetFieldM() []bool + GetFieldN() []string + GetFieldO() [][]byte +} + +func (this *CustomNameNinRepNative) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinRepNative) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinRepNativeFromFace(this) +} + +func (this *CustomNameNinRepNative) GetFieldA() []float64 { + return this.FieldA +} + +func (this *CustomNameNinRepNative) GetFieldB() []float32 { + return this.FieldB +} + +func (this *CustomNameNinRepNative) GetFieldC() []int32 { + return this.FieldC +} + +func (this *CustomNameNinRepNative) GetFieldD() []int64 { + return this.FieldD +} + +func (this *CustomNameNinRepNative) GetFieldE() []uint32 { + return this.FieldE +} + +func (this *CustomNameNinRepNative) GetFieldF() []uint64 { + return this.FieldF +} + +func (this *CustomNameNinRepNative) GetFieldG() []int32 { + return this.FieldG +} + +func (this *CustomNameNinRepNative) GetFieldH() []int64 { + return this.FieldH +} + +func (this *CustomNameNinRepNative) GetFieldI() []uint32 { + return this.FieldI +} + +func (this *CustomNameNinRepNative) GetFieldJ() []int32 { + return this.FieldJ +} + +func (this *CustomNameNinRepNative) GetFieldK() []uint64 { + return this.FieldK +} + +func (this *CustomNameNinRepNative) GetFieldL() []int64 { + return this.FieldL +} + +func (this *CustomNameNinRepNative) GetFieldM() []bool { + return this.FieldM +} + +func (this *CustomNameNinRepNative) GetFieldN() []string { + return this.FieldN +} + +func (this *CustomNameNinRepNative) GetFieldO() [][]byte { + return this.FieldO +} + +func NewCustomNameNinRepNativeFromFace(that CustomNameNinRepNativeFace) *CustomNameNinRepNative { + this := &CustomNameNinRepNative{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + this.FieldK = that.GetFieldK() + this.FieldL = that.GetFieldL() + this.FieldM = that.GetFieldM() + this.FieldN = that.GetFieldN() + this.FieldO = that.GetFieldO() + return this +} + +type CustomNameNinStructFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *float64 + GetFieldB() *float32 + GetFieldC() *NidOptNative + GetFieldD() []*NinOptNative + GetFieldE() *uint64 + GetFieldF() *int32 + GetFieldG() *NidOptNative + GetFieldH() *bool + GetFieldI() *string + GetFieldJ() []byte +} + +func (this *CustomNameNinStruct) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinStruct) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinStructFromFace(this) +} + +func (this *CustomNameNinStruct) GetFieldA() *float64 { + return this.FieldA +} + +func (this *CustomNameNinStruct) GetFieldB() *float32 { + return this.FieldB +} + +func (this *CustomNameNinStruct) GetFieldC() *NidOptNative { + return this.FieldC +} + +func (this *CustomNameNinStruct) GetFieldD() []*NinOptNative { + return this.FieldD +} + +func (this *CustomNameNinStruct) GetFieldE() *uint64 { + return this.FieldE +} + +func (this *CustomNameNinStruct) GetFieldF() *int32 { + return this.FieldF +} + +func (this *CustomNameNinStruct) GetFieldG() *NidOptNative { + return this.FieldG +} + +func (this *CustomNameNinStruct) GetFieldH() *bool { + return this.FieldH +} + +func (this *CustomNameNinStruct) GetFieldI() *string { + return this.FieldI +} + +func (this *CustomNameNinStruct) GetFieldJ() []byte { + return this.FieldJ +} + +func NewCustomNameNinStructFromFace(that CustomNameNinStructFace) *CustomNameNinStruct { + this := &CustomNameNinStruct{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + this.FieldE = that.GetFieldE() + this.FieldF = that.GetFieldF() + this.FieldG = that.GetFieldG() + this.FieldH = that.GetFieldH() + this.FieldI = that.GetFieldI() + this.FieldJ = that.GetFieldJ() + return this +} + +type CustomNameCustomTypeFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *Uuid + GetFieldB() *github_com_gogo_protobuf_test_custom.Uint128 + GetFieldC() []Uuid + GetFieldD() []github_com_gogo_protobuf_test_custom.Uint128 +} + +func (this *CustomNameCustomType) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameCustomType) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameCustomTypeFromFace(this) +} + +func (this *CustomNameCustomType) GetFieldA() *Uuid { + return this.FieldA +} + +func (this *CustomNameCustomType) GetFieldB() *github_com_gogo_protobuf_test_custom.Uint128 { + return this.FieldB +} + +func (this *CustomNameCustomType) GetFieldC() []Uuid { + return this.FieldC +} + +func (this *CustomNameCustomType) GetFieldD() []github_com_gogo_protobuf_test_custom.Uint128 { + return this.FieldD +} + +func NewCustomNameCustomTypeFromFace(that CustomNameCustomTypeFace) *CustomNameCustomType { + this := &CustomNameCustomType{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + this.FieldC = that.GetFieldC() + this.FieldD = that.GetFieldD() + return this +} + +type CustomNameNinEmbeddedStructUnionFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetNidOptNative() *NidOptNative + GetFieldA() *NinOptNative + GetFieldB() *bool +} + +func (this *CustomNameNinEmbeddedStructUnion) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameNinEmbeddedStructUnion) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameNinEmbeddedStructUnionFromFace(this) +} + +func (this *CustomNameNinEmbeddedStructUnion) GetNidOptNative() *NidOptNative { + return this.NidOptNative +} + +func (this *CustomNameNinEmbeddedStructUnion) GetFieldA() *NinOptNative { + return this.FieldA +} + +func (this *CustomNameNinEmbeddedStructUnion) GetFieldB() *bool { + return this.FieldB +} + +func NewCustomNameNinEmbeddedStructUnionFromFace(that CustomNameNinEmbeddedStructUnionFace) *CustomNameNinEmbeddedStructUnion { + this := &CustomNameNinEmbeddedStructUnion{} + this.NidOptNative = that.GetNidOptNative() + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + return this +} + +type CustomNameEnumFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetFieldA() *TheTestEnum + GetFieldB() []TheTestEnum +} + +func (this *CustomNameEnum) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *CustomNameEnum) TestProto() github_com_gogo_protobuf_proto.Message { + return NewCustomNameEnumFromFace(this) +} + +func (this *CustomNameEnum) GetFieldA() *TheTestEnum { + return this.FieldA +} + +func (this *CustomNameEnum) GetFieldB() []TheTestEnum { + return this.FieldB +} + +func NewCustomNameEnumFromFace(that CustomNameEnumFace) *CustomNameEnum { + this := &CustomNameEnum{} + this.FieldA = that.GetFieldA() + this.FieldB = that.GetFieldB() + return this +} + +type UnrecognizedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *string +} + +func (this *Unrecognized) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *Unrecognized) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedFromFace(this) +} + +func (this *Unrecognized) GetField1() *string { + return this.Field1 +} + +func NewUnrecognizedFromFace(that UnrecognizedFace) *Unrecognized { + this := &Unrecognized{} + this.Field1 = that.GetField1() + return this +} + +type UnrecognizedWithInnerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetEmbedded() []*UnrecognizedWithInner_Inner + GetField2() *string +} + +func (this *UnrecognizedWithInner) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithInner) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithInnerFromFace(this) +} + +func (this *UnrecognizedWithInner) GetEmbedded() []*UnrecognizedWithInner_Inner { + return this.Embedded +} + +func (this *UnrecognizedWithInner) GetField2() *string { + return this.Field2 +} + +func NewUnrecognizedWithInnerFromFace(that UnrecognizedWithInnerFace) *UnrecognizedWithInner { + this := &UnrecognizedWithInner{} + this.Embedded = that.GetEmbedded() + this.Field2 = that.GetField2() + return this +} + +type UnrecognizedWithInner_InnerFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *uint32 +} + +func (this *UnrecognizedWithInner_Inner) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithInner_Inner) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithInner_InnerFromFace(this) +} + +func (this *UnrecognizedWithInner_Inner) GetField1() *uint32 { + return this.Field1 +} + +func NewUnrecognizedWithInner_InnerFromFace(that UnrecognizedWithInner_InnerFace) *UnrecognizedWithInner_Inner { + this := &UnrecognizedWithInner_Inner{} + this.Field1 = that.GetField1() + return this +} + +type UnrecognizedWithEmbedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetUnrecognizedWithEmbed_Embedded() UnrecognizedWithEmbed_Embedded + GetField2() *string +} + +func (this *UnrecognizedWithEmbed) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithEmbed) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithEmbedFromFace(this) +} + +func (this *UnrecognizedWithEmbed) GetUnrecognizedWithEmbed_Embedded() UnrecognizedWithEmbed_Embedded { + return this.UnrecognizedWithEmbed_Embedded +} + +func (this *UnrecognizedWithEmbed) GetField2() *string { + return this.Field2 +} + +func NewUnrecognizedWithEmbedFromFace(that UnrecognizedWithEmbedFace) *UnrecognizedWithEmbed { + this := &UnrecognizedWithEmbed{} + this.UnrecognizedWithEmbed_Embedded = that.GetUnrecognizedWithEmbed_Embedded() + this.Field2 = that.GetField2() + return this +} + +type UnrecognizedWithEmbed_EmbeddedFace interface { + Proto() github_com_gogo_protobuf_proto.Message + GetField1() *uint32 +} + +func (this *UnrecognizedWithEmbed_Embedded) Proto() github_com_gogo_protobuf_proto.Message { + return this +} + +func (this *UnrecognizedWithEmbed_Embedded) TestProto() github_com_gogo_protobuf_proto.Message { + return NewUnrecognizedWithEmbed_EmbeddedFromFace(this) +} + +func (this *UnrecognizedWithEmbed_Embedded) GetField1() *uint32 { + return this.Field1 +} + +func NewUnrecognizedWithEmbed_EmbeddedFromFace(that UnrecognizedWithEmbed_EmbeddedFace) *UnrecognizedWithEmbed_Embedded { + this := &UnrecognizedWithEmbed_Embedded{} + this.Field1 = that.GetField1() + return this +} + +func (this *NidOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NidOptNative{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinOptNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+valueToGoStringThetest(this.Field8, "int64")+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+valueToGoStringThetest(this.Field9, "uint32")+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+valueToGoStringThetest(this.Field10, "int32")+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+valueToGoStringThetest(this.Field11, "uint64")+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+valueToGoStringThetest(this.Field12, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NidRepNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinRepNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepPackedNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 17) + s = append(s, "&test.NidRepPackedNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepPackedNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 17) + s = append(s, "&test.NinRepPackedNative{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+fmt.Sprintf("%#v", this.Field9)+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+fmt.Sprintf("%#v", this.Field10)+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+fmt.Sprintf("%#v", this.Field11)+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+fmt.Sprintf("%#v", this.Field12)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NidOptStruct{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + s = append(s, "Field3: "+strings.Replace(this.Field3.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field4: "+strings.Replace(this.Field4.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + s = append(s, "Field8: "+strings.Replace(this.Field8.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NinOptStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NidRepStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+strings.Replace(fmt.Sprintf("%#v", this.Field3), `&`, ``, 1)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+strings.Replace(fmt.Sprintf("%#v", this.Field4), `&`, ``, 1)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+strings.Replace(fmt.Sprintf("%#v", this.Field8), `&`, ``, 1)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.NinRepStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+fmt.Sprintf("%#v", this.Field6)+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+fmt.Sprintf("%#v", this.Field8)+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+fmt.Sprintf("%#v", this.Field13)+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+fmt.Sprintf("%#v", this.Field14)+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+fmt.Sprintf("%#v", this.Field15)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidEmbeddedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NidEmbeddedStruct{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + s = append(s, "Field200: "+strings.Replace(this.Field200.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Field210: "+fmt.Sprintf("%#v", this.Field210)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinEmbeddedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinEmbeddedStruct{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.Field200 != nil { + s = append(s, "Field200: "+fmt.Sprintf("%#v", this.Field200)+",\n") + } + if this.Field210 != nil { + s = append(s, "Field210: "+valueToGoStringThetest(this.Field210, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidNestedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidNestedStruct{") + s = append(s, "Field1: "+strings.Replace(this.Field1.GoString(), `&`, ``, 1)+",\n") + if this.Field2 != nil { + s = append(s, "Field2: "+strings.Replace(fmt.Sprintf("%#v", this.Field2), `&`, ``, 1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinNestedStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinNestedStruct{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidOptCustom{") + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomDash) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.CustomDash{") + if this.Value != nil { + s = append(s, "Value: "+valueToGoStringThetest(this.Value, "github_com_gogo_protobuf_test_custom_dash_type.Bytes")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinOptCustom{") + if this.Id != nil { + s = append(s, "Id: "+valueToGoStringThetest(this.Id, "Uuid")+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+valueToGoStringThetest(this.Value, "github_com_gogo_protobuf_test_custom.Uint128")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NidRepCustom{") + if this.Id != nil { + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepCustom) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NinRepCustom{") + if this.Id != nil { + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + } + if this.Value != nil { + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNativeUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 13) + s = append(s, "&test.NinOptNativeUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 13) + s = append(s, "&test.NinOptStructUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+fmt.Sprintf("%#v", this.Field4)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinEmbeddedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinEmbeddedStructUnion{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.Field200 != nil { + s = append(s, "Field200: "+fmt.Sprintf("%#v", this.Field200)+",\n") + } + if this.Field210 != nil { + s = append(s, "Field210: "+valueToGoStringThetest(this.Field210, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinNestedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NinNestedStructUnion{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Tree) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.Tree{") + if this.Or != nil { + s = append(s, "Or: "+fmt.Sprintf("%#v", this.Or)+",\n") + } + if this.And != nil { + s = append(s, "And: "+fmt.Sprintf("%#v", this.And)+",\n") + } + if this.Leaf != nil { + s = append(s, "Leaf: "+fmt.Sprintf("%#v", this.Leaf)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OrBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.OrBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AndBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.AndBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Leaf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.Leaf{") + s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n") + s = append(s, "StrValue: "+fmt.Sprintf("%#v", this.StrValue)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DeepTree) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.DeepTree{") + if this.Down != nil { + s = append(s, "Down: "+fmt.Sprintf("%#v", this.Down)+",\n") + } + if this.And != nil { + s = append(s, "And: "+fmt.Sprintf("%#v", this.And)+",\n") + } + if this.Leaf != nil { + s = append(s, "Leaf: "+fmt.Sprintf("%#v", this.Leaf)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *ADeepBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.ADeepBranch{") + s = append(s, "Down: "+strings.Replace(this.Down.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AndDeepBranch) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.AndDeepBranch{") + s = append(s, "Left: "+strings.Replace(this.Left.GoString(), `&`, ``, 1)+",\n") + s = append(s, "Right: "+strings.Replace(this.Right.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *DeepLeaf) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.DeepLeaf{") + s = append(s, "Tree: "+strings.Replace(this.Tree.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Nil) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 4) + s = append(s, "&test.Nil{") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NidOptEnum{") + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinOptEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.TheTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NidRepEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NidRepEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinRepEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinRepEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+fmt.Sprintf("%#v", this.Field1)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptEnumDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NinOptEnumDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.TheTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AnotherNinOptEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.AnotherNinOptEnum{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.AnotherTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *AnotherNinOptEnumDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.AnotherNinOptEnumDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "test.AnotherTestEnum")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Timer) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.Timer{") + s = append(s, "Time1: "+fmt.Sprintf("%#v", this.Time1)+",\n") + s = append(s, "Time2: "+fmt.Sprintf("%#v", this.Time2)+",\n") + s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *MyExtendable) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.MyExtendable{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringThetest(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OtherExtenable) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.OtherExtenable{") + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "int64")+",\n") + } + if this.M != nil { + s = append(s, "M: "+fmt.Sprintf("%#v", this.M)+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+extensionToGoStringThetest(this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&test.NestedDefinition{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.EnumField != nil { + s = append(s, "EnumField: "+valueToGoStringThetest(this.EnumField, "test.NestedDefinition_NestedEnum")+",\n") + } + if this.NNM != nil { + s = append(s, "NNM: "+fmt.Sprintf("%#v", this.NNM)+",\n") + } + if this.NM != nil { + s = append(s, "NM: "+fmt.Sprintf("%#v", this.NM)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition_NestedMessage) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.NestedDefinition_NestedMessage{") + if this.NestedField1 != nil { + s = append(s, "NestedField1: "+valueToGoStringThetest(this.NestedField1, "uint64")+",\n") + } + if this.NNM != nil { + s = append(s, "NNM: "+fmt.Sprintf("%#v", this.NNM)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NestedDefinition_NestedMessage_NestedNestedMsg{") + if this.NestedNestedField1 != nil { + s = append(s, "NestedNestedField1: "+valueToGoStringThetest(this.NestedNestedField1, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NestedScope) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.NestedScope{") + if this.A != nil { + s = append(s, "A: "+fmt.Sprintf("%#v", this.A)+",\n") + } + if this.B != nil { + s = append(s, "B: "+valueToGoStringThetest(this.B, "test.NestedDefinition_NestedEnum")+",\n") + } + if this.C != nil { + s = append(s, "C: "+fmt.Sprintf("%#v", this.C)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NinOptNativeDefault) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.NinOptNativeDefault{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "float64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "float32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringThetest(this.Field3, "int32")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringThetest(this.Field4, "int64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+valueToGoStringThetest(this.Field5, "uint32")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringThetest(this.Field6, "uint64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+valueToGoStringThetest(this.Field7, "int32")+",\n") + } + if this.Field8 != nil { + s = append(s, "Field8: "+valueToGoStringThetest(this.Field8, "int64")+",\n") + } + if this.Field9 != nil { + s = append(s, "Field9: "+valueToGoStringThetest(this.Field9, "uint32")+",\n") + } + if this.Field10 != nil { + s = append(s, "Field10: "+valueToGoStringThetest(this.Field10, "int32")+",\n") + } + if this.Field11 != nil { + s = append(s, "Field11: "+valueToGoStringThetest(this.Field11, "uint64")+",\n") + } + if this.Field12 != nil { + s = append(s, "Field12: "+valueToGoStringThetest(this.Field12, "int64")+",\n") + } + if this.Field13 != nil { + s = append(s, "Field13: "+valueToGoStringThetest(this.Field13, "bool")+",\n") + } + if this.Field14 != nil { + s = append(s, "Field14: "+valueToGoStringThetest(this.Field14, "string")+",\n") + } + if this.Field15 != nil { + s = append(s, "Field15: "+valueToGoStringThetest(this.Field15, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomContainer) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.CustomContainer{") + s = append(s, "CustomStruct: "+strings.Replace(this.CustomStruct.GoString(), `&`, ``, 1)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNidOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNidOptNative{") + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + s = append(s, "FieldE: "+fmt.Sprintf("%#v", this.FieldE)+",\n") + s = append(s, "FieldF: "+fmt.Sprintf("%#v", this.FieldF)+",\n") + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + s = append(s, "FieldH: "+fmt.Sprintf("%#v", this.FieldH)+",\n") + s = append(s, "FieldI: "+fmt.Sprintf("%#v", this.FieldI)+",\n") + s = append(s, "FieldJ: "+fmt.Sprintf("%#v", this.FieldJ)+",\n") + s = append(s, "FieldK: "+fmt.Sprintf("%#v", this.FieldK)+",\n") + s = append(s, "FieldL: "+fmt.Sprintf("%#v", this.FieldL)+",\n") + s = append(s, "FieldM: "+fmt.Sprintf("%#v", this.FieldM)+",\n") + s = append(s, "FieldN: "+fmt.Sprintf("%#v", this.FieldN)+",\n") + s = append(s, "FieldO: "+fmt.Sprintf("%#v", this.FieldO)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinOptNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNinOptNative{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "float64")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "float32")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+valueToGoStringThetest(this.FieldC, "int32")+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+valueToGoStringThetest(this.FieldD, "int64")+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+valueToGoStringThetest(this.FieldE, "uint32")+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+valueToGoStringThetest(this.FieldF, "uint64")+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+valueToGoStringThetest(this.FieldG, "int32")+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+valueToGoStringThetest(this.FieldH, "int64")+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+valueToGoStringThetest(this.FieldI, "uint32")+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+valueToGoStringThetest(this.FieldJ, "int32")+",\n") + } + if this.FieldK != nil { + s = append(s, "FieldK: "+valueToGoStringThetest(this.FieldK, "uint64")+",\n") + } + if this.FielL != nil { + s = append(s, "FielL: "+valueToGoStringThetest(this.FielL, "int64")+",\n") + } + if this.FieldM != nil { + s = append(s, "FieldM: "+valueToGoStringThetest(this.FieldM, "bool")+",\n") + } + if this.FieldN != nil { + s = append(s, "FieldN: "+valueToGoStringThetest(this.FieldN, "string")+",\n") + } + if this.FieldO != nil { + s = append(s, "FieldO: "+valueToGoStringThetest(this.FieldO, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinRepNative) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 19) + s = append(s, "&test.CustomNameNinRepNative{") + if this.FieldA != nil { + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+fmt.Sprintf("%#v", this.FieldE)+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+fmt.Sprintf("%#v", this.FieldF)+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+fmt.Sprintf("%#v", this.FieldH)+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+fmt.Sprintf("%#v", this.FieldI)+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+fmt.Sprintf("%#v", this.FieldJ)+",\n") + } + if this.FieldK != nil { + s = append(s, "FieldK: "+fmt.Sprintf("%#v", this.FieldK)+",\n") + } + if this.FieldL != nil { + s = append(s, "FieldL: "+fmt.Sprintf("%#v", this.FieldL)+",\n") + } + if this.FieldM != nil { + s = append(s, "FieldM: "+fmt.Sprintf("%#v", this.FieldM)+",\n") + } + if this.FieldN != nil { + s = append(s, "FieldN: "+fmt.Sprintf("%#v", this.FieldN)+",\n") + } + if this.FieldO != nil { + s = append(s, "FieldO: "+fmt.Sprintf("%#v", this.FieldO)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinStruct) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 14) + s = append(s, "&test.CustomNameNinStruct{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "float64")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "float32")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.FieldE != nil { + s = append(s, "FieldE: "+valueToGoStringThetest(this.FieldE, "uint64")+",\n") + } + if this.FieldF != nil { + s = append(s, "FieldF: "+valueToGoStringThetest(this.FieldF, "int32")+",\n") + } + if this.FieldG != nil { + s = append(s, "FieldG: "+fmt.Sprintf("%#v", this.FieldG)+",\n") + } + if this.FieldH != nil { + s = append(s, "FieldH: "+valueToGoStringThetest(this.FieldH, "bool")+",\n") + } + if this.FieldI != nil { + s = append(s, "FieldI: "+valueToGoStringThetest(this.FieldI, "string")+",\n") + } + if this.FieldJ != nil { + s = append(s, "FieldJ: "+valueToGoStringThetest(this.FieldJ, "byte")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameCustomType) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&test.CustomNameCustomType{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "Uuid")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "github_com_gogo_protobuf_test_custom.Uint128")+",\n") + } + if this.FieldC != nil { + s = append(s, "FieldC: "+fmt.Sprintf("%#v", this.FieldC)+",\n") + } + if this.FieldD != nil { + s = append(s, "FieldD: "+fmt.Sprintf("%#v", this.FieldD)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameNinEmbeddedStructUnion) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&test.CustomNameNinEmbeddedStructUnion{") + if this.NidOptNative != nil { + s = append(s, "NidOptNative: "+fmt.Sprintf("%#v", this.NidOptNative)+",\n") + } + if this.FieldA != nil { + s = append(s, "FieldA: "+fmt.Sprintf("%#v", this.FieldA)+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+valueToGoStringThetest(this.FieldB, "bool")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CustomNameEnum) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.CustomNameEnum{") + if this.FieldA != nil { + s = append(s, "FieldA: "+valueToGoStringThetest(this.FieldA, "test.TheTestEnum")+",\n") + } + if this.FieldB != nil { + s = append(s, "FieldB: "+fmt.Sprintf("%#v", this.FieldB)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *NoExtensionsMap) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.NoExtensionsMap{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "int64")+",\n") + } + if this.XXX_extensions != nil { + s = append(s, "XXX_extensions: "+fmt.Sprintf("%#v", this.XXX_extensions)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Unrecognized) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.Unrecognized{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "string")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithInner) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.UnrecognizedWithInner{") + if this.Embedded != nil { + s = append(s, "Embedded: "+fmt.Sprintf("%#v", this.Embedded)+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithInner_Inner) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.UnrecognizedWithInner_Inner{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "uint32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithEmbed) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&test.UnrecognizedWithEmbed{") + s = append(s, "UnrecognizedWithEmbed_Embedded: "+strings.Replace(this.UnrecognizedWithEmbed_Embedded.GoString(), `&`, ``, 1)+",\n") + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringThetest(this.Field2, "string")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnrecognizedWithEmbed_Embedded) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&test.UnrecognizedWithEmbed_Embedded{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringThetest(this.Field1, "uint32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringThetest(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringThetest(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedNidOptNative(r randyThetest, easy bool) *NidOptNative { + this := &NidOptNative{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + this.Field3 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3 *= -1 + } + this.Field4 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4 *= -1 + } + this.Field5 = uint32(r.Uint32()) + this.Field6 = uint64(uint64(r.Uint32())) + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + this.Field8 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8 *= -1 + } + this.Field9 = uint32(r.Uint32()) + this.Field10 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10 *= -1 + } + this.Field11 = uint64(uint64(r.Uint32())) + this.Field12 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12 *= -1 + } + this.Field13 = bool(bool(r.Intn(2) == 0)) + this.Field14 = randStringThetest(r) + v1 := r.Intn(100) + this.Field15 = make([]byte, v1) + for i := 0; i < v1; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinOptNative(r randyThetest, easy bool) *NinOptNative { + this := &NinOptNative{} + if r.Intn(10) != 0 { + v2 := float64(r.Float64()) + if r.Intn(2) == 0 { + v2 *= -1 + } + this.Field1 = &v2 + } + if r.Intn(10) != 0 { + v3 := float32(r.Float32()) + if r.Intn(2) == 0 { + v3 *= -1 + } + this.Field2 = &v3 + } + if r.Intn(10) != 0 { + v4 := int32(r.Int31()) + if r.Intn(2) == 0 { + v4 *= -1 + } + this.Field3 = &v4 + } + if r.Intn(10) != 0 { + v5 := int64(r.Int63()) + if r.Intn(2) == 0 { + v5 *= -1 + } + this.Field4 = &v5 + } + if r.Intn(10) != 0 { + v6 := uint32(r.Uint32()) + this.Field5 = &v6 + } + if r.Intn(10) != 0 { + v7 := uint64(uint64(r.Uint32())) + this.Field6 = &v7 + } + if r.Intn(10) != 0 { + v8 := int32(r.Int31()) + if r.Intn(2) == 0 { + v8 *= -1 + } + this.Field7 = &v8 + } + if r.Intn(10) != 0 { + v9 := int64(r.Int63()) + if r.Intn(2) == 0 { + v9 *= -1 + } + this.Field8 = &v9 + } + if r.Intn(10) != 0 { + v10 := uint32(r.Uint32()) + this.Field9 = &v10 + } + if r.Intn(10) != 0 { + v11 := int32(r.Int31()) + if r.Intn(2) == 0 { + v11 *= -1 + } + this.Field10 = &v11 + } + if r.Intn(10) != 0 { + v12 := uint64(uint64(r.Uint32())) + this.Field11 = &v12 + } + if r.Intn(10) != 0 { + v13 := int64(r.Int63()) + if r.Intn(2) == 0 { + v13 *= -1 + } + this.Field12 = &v13 + } + if r.Intn(10) != 0 { + v14 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v14 + } + if r.Intn(10) != 0 { + v15 := randStringThetest(r) + this.Field14 = &v15 + } + if r.Intn(10) != 0 { + v16 := r.Intn(100) + this.Field15 = make([]byte, v16) + for i := 0; i < v16; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepNative(r randyThetest, easy bool) *NidRepNative { + this := &NidRepNative{} + if r.Intn(10) != 0 { + v17 := r.Intn(100) + this.Field1 = make([]float64, v17) + for i := 0; i < v17; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v18 := r.Intn(100) + this.Field2 = make([]float32, v18) + for i := 0; i < v18; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v19 := r.Intn(100) + this.Field3 = make([]int32, v19) + for i := 0; i < v19; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v20 := r.Intn(100) + this.Field4 = make([]int64, v20) + for i := 0; i < v20; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v21 := r.Intn(100) + this.Field5 = make([]uint32, v21) + for i := 0; i < v21; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v22 := r.Intn(100) + this.Field6 = make([]uint64, v22) + for i := 0; i < v22; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v23 := r.Intn(100) + this.Field7 = make([]int32, v23) + for i := 0; i < v23; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v24 := r.Intn(100) + this.Field8 = make([]int64, v24) + for i := 0; i < v24; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v25 := r.Intn(100) + this.Field9 = make([]uint32, v25) + for i := 0; i < v25; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v26 := r.Intn(100) + this.Field10 = make([]int32, v26) + for i := 0; i < v26; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v27 := r.Intn(100) + this.Field11 = make([]uint64, v27) + for i := 0; i < v27; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v28 := r.Intn(100) + this.Field12 = make([]int64, v28) + for i := 0; i < v28; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v29 := r.Intn(100) + this.Field13 = make([]bool, v29) + for i := 0; i < v29; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v30 := r.Intn(10) + this.Field14 = make([]string, v30) + for i := 0; i < v30; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v31 := r.Intn(100) + this.Field15 = make([][]byte, v31) + for i := 0; i < v31; i++ { + v32 := r.Intn(100) + this.Field15[i] = make([]byte, v32) + for j := 0; j < v32; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinRepNative(r randyThetest, easy bool) *NinRepNative { + this := &NinRepNative{} + if r.Intn(10) != 0 { + v33 := r.Intn(100) + this.Field1 = make([]float64, v33) + for i := 0; i < v33; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v34 := r.Intn(100) + this.Field2 = make([]float32, v34) + for i := 0; i < v34; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v35 := r.Intn(100) + this.Field3 = make([]int32, v35) + for i := 0; i < v35; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v36 := r.Intn(100) + this.Field4 = make([]int64, v36) + for i := 0; i < v36; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v37 := r.Intn(100) + this.Field5 = make([]uint32, v37) + for i := 0; i < v37; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v38 := r.Intn(100) + this.Field6 = make([]uint64, v38) + for i := 0; i < v38; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v39 := r.Intn(100) + this.Field7 = make([]int32, v39) + for i := 0; i < v39; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v40 := r.Intn(100) + this.Field8 = make([]int64, v40) + for i := 0; i < v40; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v41 := r.Intn(100) + this.Field9 = make([]uint32, v41) + for i := 0; i < v41; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v42 := r.Intn(100) + this.Field10 = make([]int32, v42) + for i := 0; i < v42; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v43 := r.Intn(100) + this.Field11 = make([]uint64, v43) + for i := 0; i < v43; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v44 := r.Intn(100) + this.Field12 = make([]int64, v44) + for i := 0; i < v44; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v45 := r.Intn(100) + this.Field13 = make([]bool, v45) + for i := 0; i < v45; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v46 := r.Intn(10) + this.Field14 = make([]string, v46) + for i := 0; i < v46; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v47 := r.Intn(100) + this.Field15 = make([][]byte, v47) + for i := 0; i < v47; i++ { + v48 := r.Intn(100) + this.Field15[i] = make([]byte, v48) + for j := 0; j < v48; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepPackedNative(r randyThetest, easy bool) *NidRepPackedNative { + this := &NidRepPackedNative{} + if r.Intn(10) != 0 { + v49 := r.Intn(100) + this.Field1 = make([]float64, v49) + for i := 0; i < v49; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v50 := r.Intn(100) + this.Field2 = make([]float32, v50) + for i := 0; i < v50; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v51 := r.Intn(100) + this.Field3 = make([]int32, v51) + for i := 0; i < v51; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v52 := r.Intn(100) + this.Field4 = make([]int64, v52) + for i := 0; i < v52; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v53 := r.Intn(100) + this.Field5 = make([]uint32, v53) + for i := 0; i < v53; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v54 := r.Intn(100) + this.Field6 = make([]uint64, v54) + for i := 0; i < v54; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v55 := r.Intn(100) + this.Field7 = make([]int32, v55) + for i := 0; i < v55; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v56 := r.Intn(100) + this.Field8 = make([]int64, v56) + for i := 0; i < v56; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v57 := r.Intn(100) + this.Field9 = make([]uint32, v57) + for i := 0; i < v57; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v58 := r.Intn(100) + this.Field10 = make([]int32, v58) + for i := 0; i < v58; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v59 := r.Intn(100) + this.Field11 = make([]uint64, v59) + for i := 0; i < v59; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v60 := r.Intn(100) + this.Field12 = make([]int64, v60) + for i := 0; i < v60; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v61 := r.Intn(100) + this.Field13 = make([]bool, v61) + for i := 0; i < v61; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 14) + } + return this +} + +func NewPopulatedNinRepPackedNative(r randyThetest, easy bool) *NinRepPackedNative { + this := &NinRepPackedNative{} + if r.Intn(10) != 0 { + v62 := r.Intn(100) + this.Field1 = make([]float64, v62) + for i := 0; i < v62; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v63 := r.Intn(100) + this.Field2 = make([]float32, v63) + for i := 0; i < v63; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v64 := r.Intn(100) + this.Field3 = make([]int32, v64) + for i := 0; i < v64; i++ { + this.Field3[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v65 := r.Intn(100) + this.Field4 = make([]int64, v65) + for i := 0; i < v65; i++ { + this.Field4[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field4[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v66 := r.Intn(100) + this.Field5 = make([]uint32, v66) + for i := 0; i < v66; i++ { + this.Field5[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v67 := r.Intn(100) + this.Field6 = make([]uint64, v67) + for i := 0; i < v67; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v68 := r.Intn(100) + this.Field7 = make([]int32, v68) + for i := 0; i < v68; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v69 := r.Intn(100) + this.Field8 = make([]int64, v69) + for i := 0; i < v69; i++ { + this.Field8[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field8[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v70 := r.Intn(100) + this.Field9 = make([]uint32, v70) + for i := 0; i < v70; i++ { + this.Field9[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v71 := r.Intn(100) + this.Field10 = make([]int32, v71) + for i := 0; i < v71; i++ { + this.Field10[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field10[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v72 := r.Intn(100) + this.Field11 = make([]uint64, v72) + for i := 0; i < v72; i++ { + this.Field11[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v73 := r.Intn(100) + this.Field12 = make([]int64, v73) + for i := 0; i < v73; i++ { + this.Field12[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Field12[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v74 := r.Intn(100) + this.Field13 = make([]bool, v74) + for i := 0; i < v74; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 14) + } + return this +} + +func NewPopulatedNidOptStruct(r randyThetest, easy bool) *NidOptStruct { + this := &NidOptStruct{} + this.Field1 = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1 *= -1 + } + this.Field2 = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2 *= -1 + } + v75 := NewPopulatedNidOptNative(r, easy) + this.Field3 = *v75 + v76 := NewPopulatedNinOptNative(r, easy) + this.Field4 = *v76 + this.Field6 = uint64(uint64(r.Uint32())) + this.Field7 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7 *= -1 + } + v77 := NewPopulatedNidOptNative(r, easy) + this.Field8 = *v77 + this.Field13 = bool(bool(r.Intn(2) == 0)) + this.Field14 = randStringThetest(r) + v78 := r.Intn(100) + this.Field15 = make([]byte, v78) + for i := 0; i < v78; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinOptStruct(r randyThetest, easy bool) *NinOptStruct { + this := &NinOptStruct{} + if r.Intn(10) != 0 { + v79 := float64(r.Float64()) + if r.Intn(2) == 0 { + v79 *= -1 + } + this.Field1 = &v79 + } + if r.Intn(10) != 0 { + v80 := float32(r.Float32()) + if r.Intn(2) == 0 { + v80 *= -1 + } + this.Field2 = &v80 + } + if r.Intn(10) != 0 { + this.Field3 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + this.Field4 = NewPopulatedNinOptNative(r, easy) + } + if r.Intn(10) != 0 { + v81 := uint64(uint64(r.Uint32())) + this.Field6 = &v81 + } + if r.Intn(10) != 0 { + v82 := int32(r.Int31()) + if r.Intn(2) == 0 { + v82 *= -1 + } + this.Field7 = &v82 + } + if r.Intn(10) != 0 { + this.Field8 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v83 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v83 + } + if r.Intn(10) != 0 { + v84 := randStringThetest(r) + this.Field14 = &v84 + } + if r.Intn(10) != 0 { + v85 := r.Intn(100) + this.Field15 = make([]byte, v85) + for i := 0; i < v85; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidRepStruct(r randyThetest, easy bool) *NidRepStruct { + this := &NidRepStruct{} + if r.Intn(10) != 0 { + v86 := r.Intn(100) + this.Field1 = make([]float64, v86) + for i := 0; i < v86; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v87 := r.Intn(100) + this.Field2 = make([]float32, v87) + for i := 0; i < v87; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v88 := r.Intn(10) + this.Field3 = make([]NidOptNative, v88) + for i := 0; i < v88; i++ { + v89 := NewPopulatedNidOptNative(r, easy) + this.Field3[i] = *v89 + } + } + if r.Intn(10) != 0 { + v90 := r.Intn(10) + this.Field4 = make([]NinOptNative, v90) + for i := 0; i < v90; i++ { + v91 := NewPopulatedNinOptNative(r, easy) + this.Field4[i] = *v91 + } + } + if r.Intn(10) != 0 { + v92 := r.Intn(100) + this.Field6 = make([]uint64, v92) + for i := 0; i < v92; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v93 := r.Intn(100) + this.Field7 = make([]int32, v93) + for i := 0; i < v93; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v94 := r.Intn(10) + this.Field8 = make([]NidOptNative, v94) + for i := 0; i < v94; i++ { + v95 := NewPopulatedNidOptNative(r, easy) + this.Field8[i] = *v95 + } + } + if r.Intn(10) != 0 { + v96 := r.Intn(100) + this.Field13 = make([]bool, v96) + for i := 0; i < v96; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v97 := r.Intn(10) + this.Field14 = make([]string, v97) + for i := 0; i < v97; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v98 := r.Intn(100) + this.Field15 = make([][]byte, v98) + for i := 0; i < v98; i++ { + v99 := r.Intn(100) + this.Field15[i] = make([]byte, v99) + for j := 0; j < v99; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNinRepStruct(r randyThetest, easy bool) *NinRepStruct { + this := &NinRepStruct{} + if r.Intn(10) != 0 { + v100 := r.Intn(100) + this.Field1 = make([]float64, v100) + for i := 0; i < v100; i++ { + this.Field1[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field1[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v101 := r.Intn(100) + this.Field2 = make([]float32, v101) + for i := 0; i < v101; i++ { + this.Field2[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v102 := r.Intn(10) + this.Field3 = make([]*NidOptNative, v102) + for i := 0; i < v102; i++ { + this.Field3[i] = NewPopulatedNidOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v103 := r.Intn(10) + this.Field4 = make([]*NinOptNative, v103) + for i := 0; i < v103; i++ { + this.Field4[i] = NewPopulatedNinOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v104 := r.Intn(100) + this.Field6 = make([]uint64, v104) + for i := 0; i < v104; i++ { + this.Field6[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v105 := r.Intn(100) + this.Field7 = make([]int32, v105) + for i := 0; i < v105; i++ { + this.Field7[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v106 := r.Intn(10) + this.Field8 = make([]*NidOptNative, v106) + for i := 0; i < v106; i++ { + this.Field8[i] = NewPopulatedNidOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v107 := r.Intn(100) + this.Field13 = make([]bool, v107) + for i := 0; i < v107; i++ { + this.Field13[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v108 := r.Intn(10) + this.Field14 = make([]string, v108) + for i := 0; i < v108; i++ { + this.Field14[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v109 := r.Intn(100) + this.Field15 = make([][]byte, v109) + for i := 0; i < v109; i++ { + v110 := r.Intn(100) + this.Field15[i] = make([]byte, v110) + for j := 0; j < v110; j++ { + this.Field15[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedNidEmbeddedStruct(r randyThetest, easy bool) *NidEmbeddedStruct { + this := &NidEmbeddedStruct{} + if r.Intn(10) != 0 { + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + } + v111 := NewPopulatedNidOptNative(r, easy) + this.Field200 = *v111 + this.Field210 = bool(bool(r.Intn(2) == 0)) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 211) + } + return this +} + +func NewPopulatedNinEmbeddedStruct(r randyThetest, easy bool) *NinEmbeddedStruct { + this := &NinEmbeddedStruct{} + if r.Intn(10) != 0 { + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + this.Field200 = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v112 := bool(bool(r.Intn(2) == 0)) + this.Field210 = &v112 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 211) + } + return this +} + +func NewPopulatedNidNestedStruct(r randyThetest, easy bool) *NidNestedStruct { + this := &NidNestedStruct{} + v113 := NewPopulatedNidOptStruct(r, easy) + this.Field1 = *v113 + if r.Intn(10) != 0 { + v114 := r.Intn(10) + this.Field2 = make([]NidRepStruct, v114) + for i := 0; i < v114; i++ { + v115 := NewPopulatedNidRepStruct(r, easy) + this.Field2[i] = *v115 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinNestedStruct(r randyThetest, easy bool) *NinNestedStruct { + this := &NinNestedStruct{} + if r.Intn(10) != 0 { + this.Field1 = NewPopulatedNinOptStruct(r, easy) + } + if r.Intn(10) != 0 { + v116 := r.Intn(10) + this.Field2 = make([]*NinRepStruct, v116) + for i := 0; i < v116; i++ { + this.Field2[i] = NewPopulatedNinRepStruct(r, easy) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNidOptCustom(r randyThetest, easy bool) *NidOptCustom { + this := &NidOptCustom{} + v117 := NewPopulatedUuid(r) + this.Id = *v117 + v118 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value = *v118 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedCustomDash(r randyThetest, easy bool) *CustomDash { + this := &CustomDash{} + if r.Intn(10) != 0 { + this.Value = github_com_gogo_protobuf_test_custom_dash_type.NewPopulatedBytes(r) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptCustom(r randyThetest, easy bool) *NinOptCustom { + this := &NinOptCustom{} + if r.Intn(10) != 0 { + this.Id = NewPopulatedUuid(r) + } + if r.Intn(10) != 0 { + this.Value = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNidRepCustom(r randyThetest, easy bool) *NidRepCustom { + this := &NidRepCustom{} + if r.Intn(10) != 0 { + v119 := r.Intn(10) + this.Id = make([]Uuid, v119) + for i := 0; i < v119; i++ { + v120 := NewPopulatedUuid(r) + this.Id[i] = *v120 + } + } + if r.Intn(10) != 0 { + v121 := r.Intn(10) + this.Value = make([]github_com_gogo_protobuf_test_custom.Uint128, v121) + for i := 0; i < v121; i++ { + v122 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value[i] = *v122 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinRepCustom(r randyThetest, easy bool) *NinRepCustom { + this := &NinRepCustom{} + if r.Intn(10) != 0 { + v123 := r.Intn(10) + this.Id = make([]Uuid, v123) + for i := 0; i < v123; i++ { + v124 := NewPopulatedUuid(r) + this.Id[i] = *v124 + } + } + if r.Intn(10) != 0 { + v125 := r.Intn(10) + this.Value = make([]github_com_gogo_protobuf_test_custom.Uint128, v125) + for i := 0; i < v125; i++ { + v126 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.Value[i] = *v126 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNinOptNativeUnion(r randyThetest, easy bool) *NinOptNativeUnion { + this := &NinOptNativeUnion{} + fieldNum := r.Intn(9) + switch fieldNum { + case 0: + v127 := float64(r.Float64()) + if r.Intn(2) == 0 { + v127 *= -1 + } + this.Field1 = &v127 + case 1: + v128 := float32(r.Float32()) + if r.Intn(2) == 0 { + v128 *= -1 + } + this.Field2 = &v128 + case 2: + v129 := int32(r.Int31()) + if r.Intn(2) == 0 { + v129 *= -1 + } + this.Field3 = &v129 + case 3: + v130 := int64(r.Int63()) + if r.Intn(2) == 0 { + v130 *= -1 + } + this.Field4 = &v130 + case 4: + v131 := uint32(r.Uint32()) + this.Field5 = &v131 + case 5: + v132 := uint64(uint64(r.Uint32())) + this.Field6 = &v132 + case 6: + v133 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v133 + case 7: + v134 := randStringThetest(r) + this.Field14 = &v134 + case 8: + v135 := r.Intn(100) + this.Field15 = make([]byte, v135) + for i := 0; i < v135; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + return this +} + +func NewPopulatedNinOptStructUnion(r randyThetest, easy bool) *NinOptStructUnion { + this := &NinOptStructUnion{} + fieldNum := r.Intn(9) + switch fieldNum { + case 0: + v136 := float64(r.Float64()) + if r.Intn(2) == 0 { + v136 *= -1 + } + this.Field1 = &v136 + case 1: + v137 := float32(r.Float32()) + if r.Intn(2) == 0 { + v137 *= -1 + } + this.Field2 = &v137 + case 2: + this.Field3 = NewPopulatedNidOptNative(r, easy) + case 3: + this.Field4 = NewPopulatedNinOptNative(r, easy) + case 4: + v138 := uint64(uint64(r.Uint32())) + this.Field6 = &v138 + case 5: + v139 := int32(r.Int31()) + if r.Intn(2) == 0 { + v139 *= -1 + } + this.Field7 = &v139 + case 6: + v140 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v140 + case 7: + v141 := randStringThetest(r) + this.Field14 = &v141 + case 8: + v142 := r.Intn(100) + this.Field15 = make([]byte, v142) + for i := 0; i < v142; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + return this +} + +func NewPopulatedNinEmbeddedStructUnion(r randyThetest, easy bool) *NinEmbeddedStructUnion { + this := &NinEmbeddedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + case 1: + this.Field200 = NewPopulatedNinOptNative(r, easy) + case 2: + v143 := bool(bool(r.Intn(2) == 0)) + this.Field210 = &v143 + } + return this +} + +func NewPopulatedNinNestedStructUnion(r randyThetest, easy bool) *NinNestedStructUnion { + this := &NinNestedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.Field1 = NewPopulatedNinOptNativeUnion(r, easy) + case 1: + this.Field2 = NewPopulatedNinOptStructUnion(r, easy) + case 2: + this.Field3 = NewPopulatedNinEmbeddedStructUnion(r, easy) + } + return this +} + +func NewPopulatedTree(r randyThetest, easy bool) *Tree { + this := &Tree{} + fieldNum := r.Intn(102) + switch fieldNum { + case 0: + this.Or = NewPopulatedOrBranch(r, easy) + case 1: + this.And = NewPopulatedAndBranch(r, easy) + case 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101: + this.Leaf = NewPopulatedLeaf(r, easy) + } + return this +} + +func NewPopulatedOrBranch(r randyThetest, easy bool) *OrBranch { + this := &OrBranch{} + v144 := NewPopulatedTree(r, easy) + this.Left = *v144 + v145 := NewPopulatedTree(r, easy) + this.Right = *v145 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedAndBranch(r randyThetest, easy bool) *AndBranch { + this := &AndBranch{} + v146 := NewPopulatedTree(r, easy) + this.Left = *v146 + v147 := NewPopulatedTree(r, easy) + this.Right = *v147 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedLeaf(r randyThetest, easy bool) *Leaf { + this := &Leaf{} + this.Value = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Value *= -1 + } + this.StrValue = randStringThetest(r) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedDeepTree(r randyThetest, easy bool) *DeepTree { + this := &DeepTree{} + fieldNum := r.Intn(102) + switch fieldNum { + case 0: + this.Down = NewPopulatedADeepBranch(r, easy) + case 1: + this.And = NewPopulatedAndDeepBranch(r, easy) + case 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101: + this.Leaf = NewPopulatedDeepLeaf(r, easy) + } + return this +} + +func NewPopulatedADeepBranch(r randyThetest, easy bool) *ADeepBranch { + this := &ADeepBranch{} + v148 := NewPopulatedDeepTree(r, easy) + this.Down = *v148 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedAndDeepBranch(r randyThetest, easy bool) *AndDeepBranch { + this := &AndDeepBranch{} + v149 := NewPopulatedDeepTree(r, easy) + this.Left = *v149 + v150 := NewPopulatedDeepTree(r, easy) + this.Right = *v150 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedDeepLeaf(r randyThetest, easy bool) *DeepLeaf { + this := &DeepLeaf{} + v151 := NewPopulatedTree(r, easy) + this.Tree = *v151 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNil(r randyThetest, easy bool) *Nil { + this := &Nil{} + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 1) + } + return this +} + +func NewPopulatedNidOptEnum(r randyThetest, easy bool) *NidOptEnum { + this := &NidOptEnum{} + this.Field1 = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptEnum(r randyThetest, easy bool) *NinOptEnum { + this := &NinOptEnum{} + if r.Intn(10) != 0 { + v152 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.Field1 = &v152 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNidRepEnum(r randyThetest, easy bool) *NidRepEnum { + this := &NidRepEnum{} + if r.Intn(10) != 0 { + v153 := r.Intn(10) + this.Field1 = make([]TheTestEnum, v153) + for i := 0; i < v153; i++ { + this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinRepEnum(r randyThetest, easy bool) *NinRepEnum { + this := &NinRepEnum{} + if r.Intn(10) != 0 { + v154 := r.Intn(10) + this.Field1 = make([]TheTestEnum, v154) + for i := 0; i < v154; i++ { + this.Field1[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedNinOptEnumDefault(r randyThetest, easy bool) *NinOptEnumDefault { + this := &NinOptEnumDefault{} + if r.Intn(10) != 0 { + v155 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.Field1 = &v155 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedAnotherNinOptEnum(r randyThetest, easy bool) *AnotherNinOptEnum { + this := &AnotherNinOptEnum{} + if r.Intn(10) != 0 { + v156 := AnotherTestEnum([]int32{10, 11}[r.Intn(2)]) + this.Field1 = &v156 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedAnotherNinOptEnumDefault(r randyThetest, easy bool) *AnotherNinOptEnumDefault { + this := &AnotherNinOptEnumDefault{} + if r.Intn(10) != 0 { + v157 := AnotherTestEnum([]int32{10, 11}[r.Intn(2)]) + this.Field1 = &v157 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedTimer(r randyThetest, easy bool) *Timer { + this := &Timer{} + this.Time1 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Time1 *= -1 + } + this.Time2 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Time2 *= -1 + } + v158 := r.Intn(100) + this.Data = make([]byte, v158) + for i := 0; i < v158; i++ { + this.Data[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 4) + } + return this +} + +func NewPopulatedMyExtendable(r randyThetest, easy bool) *MyExtendable { + this := &MyExtendable{} + if r.Intn(10) != 0 { + v159 := int64(r.Int63()) + if r.Intn(2) == 0 { + v159 *= -1 + } + this.Field1 = &v159 + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + fieldNumber := r.Intn(100) + 100 + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 201) + } + return this +} + +func NewPopulatedOtherExtenable(r randyThetest, easy bool) *OtherExtenable { + this := &OtherExtenable{} + if r.Intn(10) != 0 { + v160 := int64(r.Int63()) + if r.Intn(2) == 0 { + v160 *= -1 + } + this.Field2 = &v160 + } + if r.Intn(10) != 0 { + v161 := int64(r.Int63()) + if r.Intn(2) == 0 { + v161 *= -1 + } + this.Field13 = &v161 + } + if r.Intn(10) != 0 { + this.M = NewPopulatedMyExtendable(r, easy) + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + eIndex := r.Intn(2) + fieldNumber := 0 + switch eIndex { + case 0: + fieldNumber = r.Intn(3) + 14 + case 1: + fieldNumber = r.Intn(3) + 10 + } + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 18) + } + return this +} + +func NewPopulatedNestedDefinition(r randyThetest, easy bool) *NestedDefinition { + this := &NestedDefinition{} + if r.Intn(10) != 0 { + v162 := int64(r.Int63()) + if r.Intn(2) == 0 { + v162 *= -1 + } + this.Field1 = &v162 + } + if r.Intn(10) != 0 { + v163 := NestedDefinition_NestedEnum([]int32{1}[r.Intn(1)]) + this.EnumField = &v163 + } + if r.Intn(10) != 0 { + this.NNM = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if r.Intn(10) != 0 { + this.NM = NewPopulatedNestedDefinition_NestedMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 5) + } + return this +} + +func NewPopulatedNestedDefinition_NestedMessage(r randyThetest, easy bool) *NestedDefinition_NestedMessage { + this := &NestedDefinition_NestedMessage{} + if r.Intn(10) != 0 { + v164 := uint64(uint64(r.Uint32())) + this.NestedField1 = &v164 + } + if r.Intn(10) != 0 { + this.NNM = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r randyThetest, easy bool) *NestedDefinition_NestedMessage_NestedNestedMsg { + this := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if r.Intn(10) != 0 { + v165 := randStringThetest(r) + this.NestedNestedField1 = &v165 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 11) + } + return this +} + +func NewPopulatedNestedScope(r randyThetest, easy bool) *NestedScope { + this := &NestedScope{} + if r.Intn(10) != 0 { + this.A = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(r, easy) + } + if r.Intn(10) != 0 { + v166 := NestedDefinition_NestedEnum([]int32{1}[r.Intn(1)]) + this.B = &v166 + } + if r.Intn(10) != 0 { + this.C = NewPopulatedNestedDefinition_NestedMessage(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 4) + } + return this +} + +func NewPopulatedNinOptNativeDefault(r randyThetest, easy bool) *NinOptNativeDefault { + this := &NinOptNativeDefault{} + if r.Intn(10) != 0 { + v167 := float64(r.Float64()) + if r.Intn(2) == 0 { + v167 *= -1 + } + this.Field1 = &v167 + } + if r.Intn(10) != 0 { + v168 := float32(r.Float32()) + if r.Intn(2) == 0 { + v168 *= -1 + } + this.Field2 = &v168 + } + if r.Intn(10) != 0 { + v169 := int32(r.Int31()) + if r.Intn(2) == 0 { + v169 *= -1 + } + this.Field3 = &v169 + } + if r.Intn(10) != 0 { + v170 := int64(r.Int63()) + if r.Intn(2) == 0 { + v170 *= -1 + } + this.Field4 = &v170 + } + if r.Intn(10) != 0 { + v171 := uint32(r.Uint32()) + this.Field5 = &v171 + } + if r.Intn(10) != 0 { + v172 := uint64(uint64(r.Uint32())) + this.Field6 = &v172 + } + if r.Intn(10) != 0 { + v173 := int32(r.Int31()) + if r.Intn(2) == 0 { + v173 *= -1 + } + this.Field7 = &v173 + } + if r.Intn(10) != 0 { + v174 := int64(r.Int63()) + if r.Intn(2) == 0 { + v174 *= -1 + } + this.Field8 = &v174 + } + if r.Intn(10) != 0 { + v175 := uint32(r.Uint32()) + this.Field9 = &v175 + } + if r.Intn(10) != 0 { + v176 := int32(r.Int31()) + if r.Intn(2) == 0 { + v176 *= -1 + } + this.Field10 = &v176 + } + if r.Intn(10) != 0 { + v177 := uint64(uint64(r.Uint32())) + this.Field11 = &v177 + } + if r.Intn(10) != 0 { + v178 := int64(r.Int63()) + if r.Intn(2) == 0 { + v178 *= -1 + } + this.Field12 = &v178 + } + if r.Intn(10) != 0 { + v179 := bool(bool(r.Intn(2) == 0)) + this.Field13 = &v179 + } + if r.Intn(10) != 0 { + v180 := randStringThetest(r) + this.Field14 = &v180 + } + if r.Intn(10) != 0 { + v181 := r.Intn(100) + this.Field15 = make([]byte, v181) + for i := 0; i < v181; i++ { + this.Field15[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomContainer(r randyThetest, easy bool) *CustomContainer { + this := &CustomContainer{} + v182 := NewPopulatedNidOptCustom(r, easy) + this.CustomStruct = *v182 + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 2) + } + return this +} + +func NewPopulatedCustomNameNidOptNative(r randyThetest, easy bool) *CustomNameNidOptNative { + this := &CustomNameNidOptNative{} + this.FieldA = float64(r.Float64()) + if r.Intn(2) == 0 { + this.FieldA *= -1 + } + this.FieldB = float32(r.Float32()) + if r.Intn(2) == 0 { + this.FieldB *= -1 + } + this.FieldC = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldC *= -1 + } + this.FieldD = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldD *= -1 + } + this.FieldE = uint32(r.Uint32()) + this.FieldF = uint64(uint64(r.Uint32())) + this.FieldG = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldG *= -1 + } + this.FieldH = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldH *= -1 + } + this.FieldI = uint32(r.Uint32()) + this.FieldJ = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldJ *= -1 + } + this.FieldK = uint64(uint64(r.Uint32())) + this.FieldL = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldL *= -1 + } + this.FieldM = bool(bool(r.Intn(2) == 0)) + this.FieldN = randStringThetest(r) + v183 := r.Intn(100) + this.FieldO = make([]byte, v183) + for i := 0; i < v183; i++ { + this.FieldO[i] = byte(r.Intn(256)) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinOptNative(r randyThetest, easy bool) *CustomNameNinOptNative { + this := &CustomNameNinOptNative{} + if r.Intn(10) != 0 { + v184 := float64(r.Float64()) + if r.Intn(2) == 0 { + v184 *= -1 + } + this.FieldA = &v184 + } + if r.Intn(10) != 0 { + v185 := float32(r.Float32()) + if r.Intn(2) == 0 { + v185 *= -1 + } + this.FieldB = &v185 + } + if r.Intn(10) != 0 { + v186 := int32(r.Int31()) + if r.Intn(2) == 0 { + v186 *= -1 + } + this.FieldC = &v186 + } + if r.Intn(10) != 0 { + v187 := int64(r.Int63()) + if r.Intn(2) == 0 { + v187 *= -1 + } + this.FieldD = &v187 + } + if r.Intn(10) != 0 { + v188 := uint32(r.Uint32()) + this.FieldE = &v188 + } + if r.Intn(10) != 0 { + v189 := uint64(uint64(r.Uint32())) + this.FieldF = &v189 + } + if r.Intn(10) != 0 { + v190 := int32(r.Int31()) + if r.Intn(2) == 0 { + v190 *= -1 + } + this.FieldG = &v190 + } + if r.Intn(10) != 0 { + v191 := int64(r.Int63()) + if r.Intn(2) == 0 { + v191 *= -1 + } + this.FieldH = &v191 + } + if r.Intn(10) != 0 { + v192 := uint32(r.Uint32()) + this.FieldI = &v192 + } + if r.Intn(10) != 0 { + v193 := int32(r.Int31()) + if r.Intn(2) == 0 { + v193 *= -1 + } + this.FieldJ = &v193 + } + if r.Intn(10) != 0 { + v194 := uint64(uint64(r.Uint32())) + this.FieldK = &v194 + } + if r.Intn(10) != 0 { + v195 := int64(r.Int63()) + if r.Intn(2) == 0 { + v195 *= -1 + } + this.FielL = &v195 + } + if r.Intn(10) != 0 { + v196 := bool(bool(r.Intn(2) == 0)) + this.FieldM = &v196 + } + if r.Intn(10) != 0 { + v197 := randStringThetest(r) + this.FieldN = &v197 + } + if r.Intn(10) != 0 { + v198 := r.Intn(100) + this.FieldO = make([]byte, v198) + for i := 0; i < v198; i++ { + this.FieldO[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinRepNative(r randyThetest, easy bool) *CustomNameNinRepNative { + this := &CustomNameNinRepNative{} + if r.Intn(10) != 0 { + v199 := r.Intn(100) + this.FieldA = make([]float64, v199) + for i := 0; i < v199; i++ { + this.FieldA[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.FieldA[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v200 := r.Intn(100) + this.FieldB = make([]float32, v200) + for i := 0; i < v200; i++ { + this.FieldB[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.FieldB[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v201 := r.Intn(100) + this.FieldC = make([]int32, v201) + for i := 0; i < v201; i++ { + this.FieldC[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldC[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v202 := r.Intn(100) + this.FieldD = make([]int64, v202) + for i := 0; i < v202; i++ { + this.FieldD[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldD[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v203 := r.Intn(100) + this.FieldE = make([]uint32, v203) + for i := 0; i < v203; i++ { + this.FieldE[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v204 := r.Intn(100) + this.FieldF = make([]uint64, v204) + for i := 0; i < v204; i++ { + this.FieldF[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v205 := r.Intn(100) + this.FieldG = make([]int32, v205) + for i := 0; i < v205; i++ { + this.FieldG[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldG[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v206 := r.Intn(100) + this.FieldH = make([]int64, v206) + for i := 0; i < v206; i++ { + this.FieldH[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldH[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v207 := r.Intn(100) + this.FieldI = make([]uint32, v207) + for i := 0; i < v207; i++ { + this.FieldI[i] = uint32(r.Uint32()) + } + } + if r.Intn(10) != 0 { + v208 := r.Intn(100) + this.FieldJ = make([]int32, v208) + for i := 0; i < v208; i++ { + this.FieldJ[i] = int32(r.Int31()) + if r.Intn(2) == 0 { + this.FieldJ[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v209 := r.Intn(100) + this.FieldK = make([]uint64, v209) + for i := 0; i < v209; i++ { + this.FieldK[i] = uint64(uint64(r.Uint32())) + } + } + if r.Intn(10) != 0 { + v210 := r.Intn(100) + this.FieldL = make([]int64, v210) + for i := 0; i < v210; i++ { + this.FieldL[i] = int64(r.Int63()) + if r.Intn(2) == 0 { + this.FieldL[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v211 := r.Intn(100) + this.FieldM = make([]bool, v211) + for i := 0; i < v211; i++ { + this.FieldM[i] = bool(bool(r.Intn(2) == 0)) + } + } + if r.Intn(10) != 0 { + v212 := r.Intn(10) + this.FieldN = make([]string, v212) + for i := 0; i < v212; i++ { + this.FieldN[i] = randStringThetest(r) + } + } + if r.Intn(10) != 0 { + v213 := r.Intn(100) + this.FieldO = make([][]byte, v213) + for i := 0; i < v213; i++ { + v214 := r.Intn(100) + this.FieldO[i] = make([]byte, v214) + for j := 0; j < v214; j++ { + this.FieldO[i][j] = byte(r.Intn(256)) + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameNinStruct(r randyThetest, easy bool) *CustomNameNinStruct { + this := &CustomNameNinStruct{} + if r.Intn(10) != 0 { + v215 := float64(r.Float64()) + if r.Intn(2) == 0 { + v215 *= -1 + } + this.FieldA = &v215 + } + if r.Intn(10) != 0 { + v216 := float32(r.Float32()) + if r.Intn(2) == 0 { + v216 *= -1 + } + this.FieldB = &v216 + } + if r.Intn(10) != 0 { + this.FieldC = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v217 := r.Intn(10) + this.FieldD = make([]*NinOptNative, v217) + for i := 0; i < v217; i++ { + this.FieldD[i] = NewPopulatedNinOptNative(r, easy) + } + } + if r.Intn(10) != 0 { + v218 := uint64(uint64(r.Uint32())) + this.FieldE = &v218 + } + if r.Intn(10) != 0 { + v219 := int32(r.Int31()) + if r.Intn(2) == 0 { + v219 *= -1 + } + this.FieldF = &v219 + } + if r.Intn(10) != 0 { + this.FieldG = NewPopulatedNidOptNative(r, easy) + } + if r.Intn(10) != 0 { + v220 := bool(bool(r.Intn(2) == 0)) + this.FieldH = &v220 + } + if r.Intn(10) != 0 { + v221 := randStringThetest(r) + this.FieldI = &v221 + } + if r.Intn(10) != 0 { + v222 := r.Intn(100) + this.FieldJ = make([]byte, v222) + for i := 0; i < v222; i++ { + this.FieldJ[i] = byte(r.Intn(256)) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 16) + } + return this +} + +func NewPopulatedCustomNameCustomType(r randyThetest, easy bool) *CustomNameCustomType { + this := &CustomNameCustomType{} + if r.Intn(10) != 0 { + this.FieldA = NewPopulatedUuid(r) + } + if r.Intn(10) != 0 { + this.FieldB = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + } + if r.Intn(10) != 0 { + v223 := r.Intn(10) + this.FieldC = make([]Uuid, v223) + for i := 0; i < v223; i++ { + v224 := NewPopulatedUuid(r) + this.FieldC[i] = *v224 + } + } + if r.Intn(10) != 0 { + v225 := r.Intn(10) + this.FieldD = make([]github_com_gogo_protobuf_test_custom.Uint128, v225) + for i := 0; i < v225; i++ { + v226 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r) + this.FieldD[i] = *v226 + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 5) + } + return this +} + +func NewPopulatedCustomNameNinEmbeddedStructUnion(r randyThetest, easy bool) *CustomNameNinEmbeddedStructUnion { + this := &CustomNameNinEmbeddedStructUnion{} + fieldNum := r.Intn(3) + switch fieldNum { + case 0: + this.NidOptNative = NewPopulatedNidOptNative(r, easy) + case 1: + this.FieldA = NewPopulatedNinOptNative(r, easy) + case 2: + v227 := bool(bool(r.Intn(2) == 0)) + this.FieldB = &v227 + } + return this +} + +func NewPopulatedCustomNameEnum(r randyThetest, easy bool) *CustomNameEnum { + this := &CustomNameEnum{} + if r.Intn(10) != 0 { + v228 := TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + this.FieldA = &v228 + } + if r.Intn(10) != 0 { + v229 := r.Intn(10) + this.FieldB = make([]TheTestEnum, v229) + for i := 0; i < v229; i++ { + this.FieldB[i] = TheTestEnum([]int32{0, 1, 2}[r.Intn(3)]) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedNoExtensionsMap(r randyThetest, easy bool) *NoExtensionsMap { + this := &NoExtensionsMap{} + if r.Intn(10) != 0 { + v230 := int64(r.Int63()) + if r.Intn(2) == 0 { + v230 *= -1 + } + this.Field1 = &v230 + } + if !easy && r.Intn(10) != 0 { + l := r.Intn(5) + for i := 0; i < l; i++ { + fieldNumber := r.Intn(100) + 100 + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + data := randFieldThetest(nil, r, fieldNumber, wire) + github_com_gogo_protobuf_proto.SetRawExtension(this, int32(fieldNumber), data) + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 201) + } + return this +} + +func NewPopulatedUnrecognized(r randyThetest, easy bool) *Unrecognized { + this := &Unrecognized{} + if r.Intn(10) != 0 { + v231 := randStringThetest(r) + this.Field1 = &v231 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedUnrecognizedWithInner(r randyThetest, easy bool) *UnrecognizedWithInner { + this := &UnrecognizedWithInner{} + if r.Intn(10) != 0 { + v232 := r.Intn(10) + this.Embedded = make([]*UnrecognizedWithInner_Inner, v232) + for i := 0; i < v232; i++ { + this.Embedded[i] = NewPopulatedUnrecognizedWithInner_Inner(r, easy) + } + } + if r.Intn(10) != 0 { + v233 := randStringThetest(r) + this.Field2 = &v233 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedUnrecognizedWithInner_Inner(r randyThetest, easy bool) *UnrecognizedWithInner_Inner { + this := &UnrecognizedWithInner_Inner{} + if r.Intn(10) != 0 { + v234 := uint32(r.Uint32()) + this.Field1 = &v234 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedUnrecognizedWithEmbed(r randyThetest, easy bool) *UnrecognizedWithEmbed { + this := &UnrecognizedWithEmbed{} + v235 := NewPopulatedUnrecognizedWithEmbed_Embedded(r, easy) + this.UnrecognizedWithEmbed_Embedded = *v235 + if r.Intn(10) != 0 { + v236 := randStringThetest(r) + this.Field2 = &v236 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedThetest(r, 3) + } + return this +} + +func NewPopulatedUnrecognizedWithEmbed_Embedded(r randyThetest, easy bool) *UnrecognizedWithEmbed_Embedded { + this := &UnrecognizedWithEmbed_Embedded{} + if r.Intn(10) != 0 { + v237 := uint32(r.Uint32()) + this.Field1 = &v237 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +type randyThetest interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneThetest(r randyThetest) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringThetest(r randyThetest) string { + v238 := r.Intn(100) + tmps := make([]rune, v238) + for i := 0; i < v238; i++ { + tmps[i] = randUTF8RuneThetest(r) + } + return string(tmps) +} +func randUnrecognizedThetest(r randyThetest, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldThetest(data, r, fieldNumber, wire) + } + return data +} +func randFieldThetest(data []byte, r randyThetest, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateThetest(data, uint64(key)) + v239 := r.Int63() + if r.Intn(2) == 0 { + v239 *= -1 + } + data = encodeVarintPopulateThetest(data, uint64(v239)) + case 1: + data = encodeVarintPopulateThetest(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateThetest(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateThetest(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateThetest(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateThetest(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *NidOptNative) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + n += 1 + sovThetest(uint64(m.Field3)) + n += 1 + sovThetest(uint64(m.Field4)) + n += 1 + sovThetest(uint64(m.Field5)) + n += 1 + sovThetest(uint64(m.Field6)) + n += 1 + sozThetest(uint64(m.Field7)) + n += 1 + sozThetest(uint64(m.Field8)) + n += 5 + n += 5 + n += 9 + n += 9 + n += 2 + l = len(m.Field14) + n += 1 + l + sovThetest(uint64(l)) + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNative) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + n += 1 + sozThetest(uint64(*m.Field8)) + } + if m.Field9 != nil { + n += 5 + } + if m.Field10 != nil { + n += 5 + } + if m.Field11 != nil { + n += 9 + } + if m.Field12 != nil { + n += 9 + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field5) > 0 { + for _, e := range m.Field5 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field9) > 0 { + n += 5 * len(m.Field9) + } + if len(m.Field10) > 0 { + n += 5 * len(m.Field10) + } + if len(m.Field11) > 0 { + n += 9 * len(m.Field11) + } + if len(m.Field12) > 0 { + n += 9 * len(m.Field12) + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field5) > 0 { + for _, e := range m.Field5 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field9) > 0 { + n += 5 * len(m.Field9) + } + if len(m.Field10) > 0 { + n += 5 * len(m.Field10) + } + if len(m.Field11) > 0 { + n += 9 * len(m.Field11) + } + if len(m.Field12) > 0 { + n += 9 * len(m.Field12) + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepPackedNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 1 + sovThetest(uint64(len(m.Field1)*8)) + len(m.Field1)*8 + } + if len(m.Field2) > 0 { + n += 1 + sovThetest(uint64(len(m.Field2)*4)) + len(m.Field2)*4 + } + if len(m.Field3) > 0 { + l = 0 + for _, e := range m.Field3 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field4) > 0 { + l = 0 + for _, e := range m.Field4 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field5) > 0 { + l = 0 + for _, e := range m.Field5 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field6) > 0 { + l = 0 + for _, e := range m.Field6 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field7) > 0 { + l = 0 + for _, e := range m.Field7 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field8) > 0 { + l = 0 + for _, e := range m.Field8 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field9) > 0 { + n += 1 + sovThetest(uint64(len(m.Field9)*4)) + len(m.Field9)*4 + } + if len(m.Field10) > 0 { + n += 1 + sovThetest(uint64(len(m.Field10)*4)) + len(m.Field10)*4 + } + if len(m.Field11) > 0 { + n += 1 + sovThetest(uint64(len(m.Field11)*8)) + len(m.Field11)*8 + } + if len(m.Field12) > 0 { + n += 1 + sovThetest(uint64(len(m.Field12)*8)) + len(m.Field12)*8 + } + if len(m.Field13) > 0 { + n += 1 + sovThetest(uint64(len(m.Field13))) + len(m.Field13)*1 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepPackedNative) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 1 + sovThetest(uint64(len(m.Field1)*8)) + len(m.Field1)*8 + } + if len(m.Field2) > 0 { + n += 1 + sovThetest(uint64(len(m.Field2)*4)) + len(m.Field2)*4 + } + if len(m.Field3) > 0 { + l = 0 + for _, e := range m.Field3 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field4) > 0 { + l = 0 + for _, e := range m.Field4 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field5) > 0 { + l = 0 + for _, e := range m.Field5 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field6) > 0 { + l = 0 + for _, e := range m.Field6 { + l += sovThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field7) > 0 { + l = 0 + for _, e := range m.Field7 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field8) > 0 { + l = 0 + for _, e := range m.Field8 { + l += sozThetest(uint64(e)) + } + n += 1 + sovThetest(uint64(l)) + l + } + if len(m.Field9) > 0 { + n += 1 + sovThetest(uint64(len(m.Field9)*4)) + len(m.Field9)*4 + } + if len(m.Field10) > 0 { + n += 1 + sovThetest(uint64(len(m.Field10)*4)) + len(m.Field10)*4 + } + if len(m.Field11) > 0 { + n += 1 + sovThetest(uint64(len(m.Field11)*8)) + len(m.Field11)*8 + } + if len(m.Field12) > 0 { + n += 1 + sovThetest(uint64(len(m.Field12)*8)) + len(m.Field12)*8 + } + if len(m.Field13) > 0 { + n += 1 + sovThetest(uint64(len(m.Field13))) + len(m.Field13)*1 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptStruct) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + n += 1 + sovThetest(uint64(m.Field6)) + n += 1 + sozThetest(uint64(m.Field7)) + l = m.Field8.Size() + n += 1 + l + sovThetest(uint64(l)) + n += 2 + l = len(m.Field14) + n += 1 + l + sovThetest(uint64(l)) + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptStruct) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field4 != nil { + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + l = m.Field8.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepStruct) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepStruct) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + n += 9 * len(m.Field1) + } + if len(m.Field2) > 0 { + n += 5 * len(m.Field2) + } + if len(m.Field3) > 0 { + for _, e := range m.Field3 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field4) > 0 { + for _, e := range m.Field4 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field6) > 0 { + for _, e := range m.Field6 { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.Field7) > 0 { + for _, e := range m.Field7 { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.Field8) > 0 { + for _, e := range m.Field8 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field13) > 0 { + n += 2 * len(m.Field13) + } + if len(m.Field14) > 0 { + for _, s := range m.Field14 { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Field15) > 0 { + for _, b := range m.Field15 { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidEmbeddedStruct) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + n += 3 + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinEmbeddedStruct) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field200 != nil { + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.Field210 != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidNestedStruct) Size() (n int) { + var l int + _ = l + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + if len(m.Field2) > 0 { + for _, e := range m.Field2 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinNestedStruct) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.Field2) > 0 { + for _, e := range m.Field2 { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptCustom) Size() (n int) { + var l int + _ = l + l = m.Id.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomDash) Size() (n int) { + var l int + _ = l + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptCustom) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Value != nil { + l = m.Value.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepCustom) Size() (n int) { + var l int + _ = l + if len(m.Id) > 0 { + for _, e := range m.Id { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Value) > 0 { + for _, e := range m.Value { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepCustom) Size() (n int) { + var l int + _ = l + if len(m.Id) > 0 { + for _, e := range m.Id { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.Value) > 0 { + for _, e := range m.Value { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNativeUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptStructUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field4 != nil { + l = m.Field4.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinEmbeddedStructUnion) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field200 != nil { + l = m.Field200.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.Field210 != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinNestedStructUnion) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = m.Field1.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field2 != nil { + l = m.Field2.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field3 != nil { + l = m.Field3.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Tree) Size() (n int) { + var l int + _ = l + if m.Or != nil { + l = m.Or.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.And != nil { + l = m.And.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Leaf != nil { + l = m.Leaf.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *OrBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AndBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Leaf) Size() (n int) { + var l int + _ = l + n += 1 + sovThetest(uint64(m.Value)) + l = len(m.StrValue) + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DeepTree) Size() (n int) { + var l int + _ = l + if m.Down != nil { + l = m.Down.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.And != nil { + l = m.And.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.Leaf != nil { + l = m.Leaf.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *ADeepBranch) Size() (n int) { + var l int + _ = l + l = m.Down.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AndDeepBranch) Size() (n int) { + var l int + _ = l + l = m.Left.Size() + n += 1 + l + sovThetest(uint64(l)) + l = m.Right.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DeepLeaf) Size() (n int) { + var l int + _ = l + l = m.Tree.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Nil) Size() (n int) { + var l int + _ = l + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidOptEnum) Size() (n int) { + var l int + _ = l + n += 1 + sovThetest(uint64(m.Field1)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptEnum) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NidRepEnum) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + for _, e := range m.Field1 { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinRepEnum) Size() (n int) { + var l int + _ = l + if len(m.Field1) > 0 { + for _, e := range m.Field1 { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptEnumDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AnotherNinOptEnum) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *AnotherNinOptEnumDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Timer) Size() (n int) { + var l int + _ = l + n += 9 + n += 9 + if m.Data != nil { + l = len(m.Data) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *MyExtendable) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + n += github_com_gogo_protobuf_proto.SizeOfExtensionMap(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *OtherExtenable) Size() (n int) { + var l int + _ = l + if m.Field2 != nil { + n += 1 + sovThetest(uint64(*m.Field2)) + } + if m.Field13 != nil { + n += 1 + sovThetest(uint64(*m.Field13)) + } + if m.M != nil { + l = m.M.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_extensions != nil { + n += github_com_gogo_protobuf_proto.SizeOfExtensionMap(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.EnumField != nil { + n += 1 + sovThetest(uint64(*m.EnumField)) + } + if m.NNM != nil { + l = m.NNM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.NM != nil { + l = m.NM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition_NestedMessage) Size() (n int) { + var l int + _ = l + if m.NestedField1 != nil { + n += 9 + } + if m.NNM != nil { + l = m.NNM.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedDefinition_NestedMessage_NestedNestedMsg) Size() (n int) { + var l int + _ = l + if m.NestedNestedField1 != nil { + l = len(*m.NestedNestedField1) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NestedScope) Size() (n int) { + var l int + _ = l + if m.A != nil { + l = m.A.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.B != nil { + n += 1 + sovThetest(uint64(*m.B)) + } + if m.C != nil { + l = m.C.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NinOptNativeDefault) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 9 + } + if m.Field2 != nil { + n += 5 + } + if m.Field3 != nil { + n += 1 + sovThetest(uint64(*m.Field3)) + } + if m.Field4 != nil { + n += 1 + sovThetest(uint64(*m.Field4)) + } + if m.Field5 != nil { + n += 1 + sovThetest(uint64(*m.Field5)) + } + if m.Field6 != nil { + n += 1 + sovThetest(uint64(*m.Field6)) + } + if m.Field7 != nil { + n += 1 + sozThetest(uint64(*m.Field7)) + } + if m.Field8 != nil { + n += 1 + sozThetest(uint64(*m.Field8)) + } + if m.Field9 != nil { + n += 5 + } + if m.Field10 != nil { + n += 5 + } + if m.Field11 != nil { + n += 9 + } + if m.Field12 != nil { + n += 9 + } + if m.Field13 != nil { + n += 2 + } + if m.Field14 != nil { + l = len(*m.Field14) + n += 1 + l + sovThetest(uint64(l)) + } + if m.Field15 != nil { + l = len(m.Field15) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomContainer) Size() (n int) { + var l int + _ = l + l = m.CustomStruct.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNidOptNative) Size() (n int) { + var l int + _ = l + n += 9 + n += 5 + n += 1 + sovThetest(uint64(m.FieldC)) + n += 1 + sovThetest(uint64(m.FieldD)) + n += 1 + sovThetest(uint64(m.FieldE)) + n += 1 + sovThetest(uint64(m.FieldF)) + n += 1 + sozThetest(uint64(m.FieldG)) + n += 1 + sozThetest(uint64(m.FieldH)) + n += 5 + n += 5 + n += 9 + n += 9 + n += 2 + l = len(m.FieldN) + n += 1 + l + sovThetest(uint64(l)) + if m.FieldO != nil { + l = len(m.FieldO) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinOptNative) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 9 + } + if m.FieldB != nil { + n += 5 + } + if m.FieldC != nil { + n += 1 + sovThetest(uint64(*m.FieldC)) + } + if m.FieldD != nil { + n += 1 + sovThetest(uint64(*m.FieldD)) + } + if m.FieldE != nil { + n += 1 + sovThetest(uint64(*m.FieldE)) + } + if m.FieldF != nil { + n += 1 + sovThetest(uint64(*m.FieldF)) + } + if m.FieldG != nil { + n += 1 + sozThetest(uint64(*m.FieldG)) + } + if m.FieldH != nil { + n += 1 + sozThetest(uint64(*m.FieldH)) + } + if m.FieldI != nil { + n += 5 + } + if m.FieldJ != nil { + n += 5 + } + if m.FieldK != nil { + n += 9 + } + if m.FielL != nil { + n += 9 + } + if m.FieldM != nil { + n += 2 + } + if m.FieldN != nil { + l = len(*m.FieldN) + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldO != nil { + l = len(m.FieldO) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinRepNative) Size() (n int) { + var l int + _ = l + if len(m.FieldA) > 0 { + n += 9 * len(m.FieldA) + } + if len(m.FieldB) > 0 { + n += 5 * len(m.FieldB) + } + if len(m.FieldC) > 0 { + for _, e := range m.FieldC { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldE) > 0 { + for _, e := range m.FieldE { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldF) > 0 { + for _, e := range m.FieldF { + n += 1 + sovThetest(uint64(e)) + } + } + if len(m.FieldG) > 0 { + for _, e := range m.FieldG { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.FieldH) > 0 { + for _, e := range m.FieldH { + n += 1 + sozThetest(uint64(e)) + } + } + if len(m.FieldI) > 0 { + n += 5 * len(m.FieldI) + } + if len(m.FieldJ) > 0 { + n += 5 * len(m.FieldJ) + } + if len(m.FieldK) > 0 { + n += 9 * len(m.FieldK) + } + if len(m.FieldL) > 0 { + n += 9 * len(m.FieldL) + } + if len(m.FieldM) > 0 { + n += 2 * len(m.FieldM) + } + if len(m.FieldN) > 0 { + for _, s := range m.FieldN { + l = len(s) + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.FieldO) > 0 { + for _, b := range m.FieldO { + l = len(b) + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinStruct) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 9 + } + if m.FieldB != nil { + n += 5 + } + if m.FieldC != nil { + l = m.FieldC.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.FieldE != nil { + n += 1 + sovThetest(uint64(*m.FieldE)) + } + if m.FieldF != nil { + n += 1 + sozThetest(uint64(*m.FieldF)) + } + if m.FieldG != nil { + l = m.FieldG.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldH != nil { + n += 2 + } + if m.FieldI != nil { + l = len(*m.FieldI) + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldJ != nil { + l = len(m.FieldJ) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameCustomType) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + l = m.FieldA.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldB != nil { + l = m.FieldB.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if len(m.FieldC) > 0 { + for _, e := range m.FieldC { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if len(m.FieldD) > 0 { + for _, e := range m.FieldD { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameNinEmbeddedStructUnion) Size() (n int) { + var l int + _ = l + if m.NidOptNative != nil { + l = m.NidOptNative.Size() + n += 1 + l + sovThetest(uint64(l)) + } + if m.FieldA != nil { + l = m.FieldA.Size() + n += 2 + l + sovThetest(uint64(l)) + } + if m.FieldB != nil { + n += 3 + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *CustomNameEnum) Size() (n int) { + var l int + _ = l + if m.FieldA != nil { + n += 1 + sovThetest(uint64(*m.FieldA)) + } + if len(m.FieldB) > 0 { + for _, e := range m.FieldB { + n += 1 + sovThetest(uint64(e)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *NoExtensionsMap) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + if m.XXX_extensions != nil { + n += len(m.XXX_extensions) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *Unrecognized) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = len(*m.Field1) + n += 1 + l + sovThetest(uint64(l)) + } + return n +} + +func (m *UnrecognizedWithInner) Size() (n int) { + var l int + _ = l + if len(m.Embedded) > 0 { + for _, e := range m.Embedded { + l = e.Size() + n += 1 + l + sovThetest(uint64(l)) + } + } + if m.Field2 != nil { + l = len(*m.Field2) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UnrecognizedWithInner_Inner) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + return n +} + +func (m *UnrecognizedWithEmbed) Size() (n int) { + var l int + _ = l + l = m.UnrecognizedWithEmbed_Embedded.Size() + n += 1 + l + sovThetest(uint64(l)) + if m.Field2 != nil { + l = len(*m.Field2) + n += 1 + l + sovThetest(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UnrecognizedWithEmbed_Embedded) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovThetest(uint64(*m.Field1)) + } + return n +} + +func sovThetest(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozThetest(x uint64) (n int) { + return sovThetest(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *NidOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNative{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + valueToStringThetest(this.Field8) + `,`, + `Field9:` + valueToStringThetest(this.Field9) + `,`, + `Field10:` + valueToStringThetest(this.Field10) + `,`, + `Field11:` + valueToStringThetest(this.Field11) + `,`, + `Field12:` + valueToStringThetest(this.Field12) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepPackedNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepPackedNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepPackedNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepPackedNative{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Field4:` + fmt.Sprintf("%v", this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + fmt.Sprintf("%v", this.Field8) + `,`, + `Field9:` + fmt.Sprintf("%v", this.Field9) + `,`, + `Field10:` + fmt.Sprintf("%v", this.Field10) + `,`, + `Field11:` + fmt.Sprintf("%v", this.Field11) + `,`, + `Field12:` + fmt.Sprintf("%v", this.Field12) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(strings.Replace(this.Field3.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field4:` + strings.Replace(strings.Replace(this.Field4.String(), "NinOptNative", "NinOptNative", 1), `&`, ``, 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(strings.Replace(this.Field8.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptStruct{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field4:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1), `&`, ``, 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepStruct{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + fmt.Sprintf("%v", this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `Field8:` + strings.Replace(fmt.Sprintf("%v", this.Field8), "NidOptNative", "NidOptNative", 1) + `,`, + `Field13:` + fmt.Sprintf("%v", this.Field13) + `,`, + `Field14:` + fmt.Sprintf("%v", this.Field14) + `,`, + `Field15:` + fmt.Sprintf("%v", this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidEmbeddedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidEmbeddedStruct{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(strings.Replace(this.Field200.String(), "NidOptNative", "NidOptNative", 1), `&`, ``, 1) + `,`, + `Field210:` + fmt.Sprintf("%v", this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinEmbeddedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinEmbeddedStruct{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(fmt.Sprintf("%v", this.Field200), "NidOptNative", "NidOptNative", 1) + `,`, + `Field210:` + valueToStringThetest(this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidNestedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidNestedStruct{`, + `Field1:` + strings.Replace(strings.Replace(this.Field1.String(), "NidOptStruct", "NidOptStruct", 1), `&`, ``, 1) + `,`, + `Field2:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Field2), "NidRepStruct", "NidRepStruct", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinNestedStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinNestedStruct{`, + `Field1:` + strings.Replace(fmt.Sprintf("%v", this.Field1), "NinOptStruct", "NinOptStruct", 1) + `,`, + `Field2:` + strings.Replace(fmt.Sprintf("%v", this.Field2), "NinRepStruct", "NinRepStruct", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomDash) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomDash{`, + `Value:` + valueToStringThetest(this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptCustom{`, + `Id:` + valueToStringThetest(this.Id) + `,`, + `Value:` + valueToStringThetest(this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepCustom) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepCustom{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNativeUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNativeUnion{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptStructUnion{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NidOptNative", "NidOptNative", 1) + `,`, + `Field4:` + strings.Replace(fmt.Sprintf("%v", this.Field4), "NinOptNative", "NinOptNative", 1) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinEmbeddedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinEmbeddedStructUnion{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `Field200:` + strings.Replace(fmt.Sprintf("%v", this.Field200), "NinOptNative", "NinOptNative", 1) + `,`, + `Field210:` + valueToStringThetest(this.Field210) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinNestedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinNestedStructUnion{`, + `Field1:` + strings.Replace(fmt.Sprintf("%v", this.Field1), "NinOptNativeUnion", "NinOptNativeUnion", 1) + `,`, + `Field2:` + strings.Replace(fmt.Sprintf("%v", this.Field2), "NinOptStructUnion", "NinOptStructUnion", 1) + `,`, + `Field3:` + strings.Replace(fmt.Sprintf("%v", this.Field3), "NinEmbeddedStructUnion", "NinEmbeddedStructUnion", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Tree) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Tree{`, + `Or:` + strings.Replace(fmt.Sprintf("%v", this.Or), "OrBranch", "OrBranch", 1) + `,`, + `And:` + strings.Replace(fmt.Sprintf("%v", this.And), "AndBranch", "AndBranch", 1) + `,`, + `Leaf:` + strings.Replace(fmt.Sprintf("%v", this.Leaf), "Leaf", "Leaf", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OrBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OrBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AndBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AndBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Leaf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Leaf{`, + `Value:` + fmt.Sprintf("%v", this.Value) + `,`, + `StrValue:` + fmt.Sprintf("%v", this.StrValue) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *DeepTree) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DeepTree{`, + `Down:` + strings.Replace(fmt.Sprintf("%v", this.Down), "ADeepBranch", "ADeepBranch", 1) + `,`, + `And:` + strings.Replace(fmt.Sprintf("%v", this.And), "AndDeepBranch", "AndDeepBranch", 1) + `,`, + `Leaf:` + strings.Replace(fmt.Sprintf("%v", this.Leaf), "DeepLeaf", "DeepLeaf", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *ADeepBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ADeepBranch{`, + `Down:` + strings.Replace(strings.Replace(this.Down.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AndDeepBranch) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AndDeepBranch{`, + `Left:` + strings.Replace(strings.Replace(this.Left.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `Right:` + strings.Replace(strings.Replace(this.Right.String(), "DeepTree", "DeepTree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *DeepLeaf) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&DeepLeaf{`, + `Tree:` + strings.Replace(strings.Replace(this.Tree.String(), "Tree", "Tree", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Nil) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Nil{`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidOptEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptEnum{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NidRepEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NidRepEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinRepEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinRepEnum{`, + `Field1:` + fmt.Sprintf("%v", this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptEnumDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptEnumDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AnotherNinOptEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnotherNinOptEnum{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *AnotherNinOptEnumDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&AnotherNinOptEnumDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Timer) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Timer{`, + `Time1:` + fmt.Sprintf("%v", this.Time1) + `,`, + `Time2:` + fmt.Sprintf("%v", this.Time2) + `,`, + `Data:` + fmt.Sprintf("%v", this.Data) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *MyExtendable) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&MyExtendable{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsMap(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OtherExtenable) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OtherExtenable{`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `M:` + strings.Replace(fmt.Sprintf("%v", this.M), "MyExtendable", "MyExtendable", 1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsMap(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `EnumField:` + valueToStringThetest(this.EnumField) + `,`, + `NNM:` + strings.Replace(fmt.Sprintf("%v", this.NNM), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `NM:` + strings.Replace(fmt.Sprintf("%v", this.NM), "NestedDefinition_NestedMessage", "NestedDefinition_NestedMessage", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition_NestedMessage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition_NestedMessage{`, + `NestedField1:` + valueToStringThetest(this.NestedField1) + `,`, + `NNM:` + strings.Replace(fmt.Sprintf("%v", this.NNM), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedDefinition_NestedMessage_NestedNestedMsg) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedDefinition_NestedMessage_NestedNestedMsg{`, + `NestedNestedField1:` + valueToStringThetest(this.NestedNestedField1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NestedScope) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NestedScope{`, + `A:` + strings.Replace(fmt.Sprintf("%v", this.A), "NestedDefinition_NestedMessage_NestedNestedMsg", "NestedDefinition_NestedMessage_NestedNestedMsg", 1) + `,`, + `B:` + valueToStringThetest(this.B) + `,`, + `C:` + strings.Replace(fmt.Sprintf("%v", this.C), "NestedDefinition_NestedMessage", "NestedDefinition_NestedMessage", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NinOptNativeDefault) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NinOptNativeDefault{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `Field3:` + valueToStringThetest(this.Field3) + `,`, + `Field4:` + valueToStringThetest(this.Field4) + `,`, + `Field5:` + valueToStringThetest(this.Field5) + `,`, + `Field6:` + valueToStringThetest(this.Field6) + `,`, + `Field7:` + valueToStringThetest(this.Field7) + `,`, + `Field8:` + valueToStringThetest(this.Field8) + `,`, + `Field9:` + valueToStringThetest(this.Field9) + `,`, + `Field10:` + valueToStringThetest(this.Field10) + `,`, + `Field11:` + valueToStringThetest(this.Field11) + `,`, + `Field12:` + valueToStringThetest(this.Field12) + `,`, + `Field13:` + valueToStringThetest(this.Field13) + `,`, + `Field14:` + valueToStringThetest(this.Field14) + `,`, + `Field15:` + valueToStringThetest(this.Field15) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomContainer) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomContainer{`, + `CustomStruct:` + strings.Replace(strings.Replace(this.CustomStruct.String(), "NidOptCustom", "NidOptCustom", 1), `&`, ``, 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNidOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNidOptNative{`, + `FieldA:` + fmt.Sprintf("%v", this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `FieldE:` + fmt.Sprintf("%v", this.FieldE) + `,`, + `FieldF:` + fmt.Sprintf("%v", this.FieldF) + `,`, + `FieldG:` + fmt.Sprintf("%v", this.FieldG) + `,`, + `FieldH:` + fmt.Sprintf("%v", this.FieldH) + `,`, + `FieldI:` + fmt.Sprintf("%v", this.FieldI) + `,`, + `FieldJ:` + fmt.Sprintf("%v", this.FieldJ) + `,`, + `FieldK:` + fmt.Sprintf("%v", this.FieldK) + `,`, + `FieldL:` + fmt.Sprintf("%v", this.FieldL) + `,`, + `FieldM:` + fmt.Sprintf("%v", this.FieldM) + `,`, + `FieldN:` + fmt.Sprintf("%v", this.FieldN) + `,`, + `FieldO:` + fmt.Sprintf("%v", this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinOptNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinOptNative{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + valueToStringThetest(this.FieldC) + `,`, + `FieldD:` + valueToStringThetest(this.FieldD) + `,`, + `FieldE:` + valueToStringThetest(this.FieldE) + `,`, + `FieldF:` + valueToStringThetest(this.FieldF) + `,`, + `FieldG:` + valueToStringThetest(this.FieldG) + `,`, + `FieldH:` + valueToStringThetest(this.FieldH) + `,`, + `FieldI:` + valueToStringThetest(this.FieldI) + `,`, + `FieldJ:` + valueToStringThetest(this.FieldJ) + `,`, + `FieldK:` + valueToStringThetest(this.FieldK) + `,`, + `FielL:` + valueToStringThetest(this.FielL) + `,`, + `FieldM:` + valueToStringThetest(this.FieldM) + `,`, + `FieldN:` + valueToStringThetest(this.FieldN) + `,`, + `FieldO:` + valueToStringThetest(this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinRepNative) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinRepNative{`, + `FieldA:` + fmt.Sprintf("%v", this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `FieldE:` + fmt.Sprintf("%v", this.FieldE) + `,`, + `FieldF:` + fmt.Sprintf("%v", this.FieldF) + `,`, + `FieldG:` + fmt.Sprintf("%v", this.FieldG) + `,`, + `FieldH:` + fmt.Sprintf("%v", this.FieldH) + `,`, + `FieldI:` + fmt.Sprintf("%v", this.FieldI) + `,`, + `FieldJ:` + fmt.Sprintf("%v", this.FieldJ) + `,`, + `FieldK:` + fmt.Sprintf("%v", this.FieldK) + `,`, + `FieldL:` + fmt.Sprintf("%v", this.FieldL) + `,`, + `FieldM:` + fmt.Sprintf("%v", this.FieldM) + `,`, + `FieldN:` + fmt.Sprintf("%v", this.FieldN) + `,`, + `FieldO:` + fmt.Sprintf("%v", this.FieldO) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinStruct) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinStruct{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + strings.Replace(fmt.Sprintf("%v", this.FieldC), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldD:` + strings.Replace(fmt.Sprintf("%v", this.FieldD), "NinOptNative", "NinOptNative", 1) + `,`, + `FieldE:` + valueToStringThetest(this.FieldE) + `,`, + `FieldF:` + valueToStringThetest(this.FieldF) + `,`, + `FieldG:` + strings.Replace(fmt.Sprintf("%v", this.FieldG), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldH:` + valueToStringThetest(this.FieldH) + `,`, + `FieldI:` + valueToStringThetest(this.FieldI) + `,`, + `FieldJ:` + valueToStringThetest(this.FieldJ) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameCustomType) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameCustomType{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `FieldC:` + fmt.Sprintf("%v", this.FieldC) + `,`, + `FieldD:` + fmt.Sprintf("%v", this.FieldD) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameNinEmbeddedStructUnion) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameNinEmbeddedStructUnion{`, + `NidOptNative:` + strings.Replace(fmt.Sprintf("%v", this.NidOptNative), "NidOptNative", "NidOptNative", 1) + `,`, + `FieldA:` + strings.Replace(fmt.Sprintf("%v", this.FieldA), "NinOptNative", "NinOptNative", 1) + `,`, + `FieldB:` + valueToStringThetest(this.FieldB) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *CustomNameEnum) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&CustomNameEnum{`, + `FieldA:` + valueToStringThetest(this.FieldA) + `,`, + `FieldB:` + fmt.Sprintf("%v", this.FieldB) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *NoExtensionsMap) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NoExtensionsMap{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `XXX_extensions:` + proto.StringFromExtensionsBytes(this.XXX_extensions) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Unrecognized) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Unrecognized{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithInner) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithInner{`, + `Embedded:` + strings.Replace(fmt.Sprintf("%v", this.Embedded), "UnrecognizedWithInner_Inner", "UnrecognizedWithInner_Inner", 1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithInner_Inner) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithInner_Inner{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithEmbed) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithEmbed{`, + `UnrecognizedWithEmbed_Embedded:` + strings.Replace(strings.Replace(this.UnrecognizedWithEmbed_Embedded.String(), "UnrecognizedWithEmbed_Embedded", "UnrecognizedWithEmbed_Embedded", 1), `&`, ``, 1) + `,`, + `Field2:` + valueToStringThetest(this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *UnrecognizedWithEmbed_Embedded) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnrecognizedWithEmbed_Embedded{`, + `Field1:` + valueToStringThetest(this.Field1) + `,`, + `}`, + }, "") + return s +} +func valueToStringThetest(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (this *NinOptNativeUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + if this.Field4 != nil { + return this.Field4 + } + if this.Field5 != nil { + return this.Field5 + } + if this.Field6 != nil { + return this.Field6 + } + if this.Field13 != nil { + return this.Field13 + } + if this.Field14 != nil { + return this.Field14 + } + if this.Field15 != nil { + return this.Field15 + } + return nil +} + +func (this *NinOptNativeUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *float64: + this.Field1 = vt + case *float32: + this.Field2 = vt + case *int32: + this.Field3 = vt + case *int64: + this.Field4 = vt + case *uint32: + this.Field5 = vt + case *uint64: + this.Field6 = vt + case *bool: + this.Field13 = vt + case *string: + this.Field14 = vt + case []byte: + this.Field15 = vt + default: + return false + } + return true +} +func (this *NinOptStructUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + if this.Field4 != nil { + return this.Field4 + } + if this.Field6 != nil { + return this.Field6 + } + if this.Field7 != nil { + return this.Field7 + } + if this.Field13 != nil { + return this.Field13 + } + if this.Field14 != nil { + return this.Field14 + } + if this.Field15 != nil { + return this.Field15 + } + return nil +} + +func (this *NinOptStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *float64: + this.Field1 = vt + case *float32: + this.Field2 = vt + case *NidOptNative: + this.Field3 = vt + case *NinOptNative: + this.Field4 = vt + case *uint64: + this.Field6 = vt + case *int32: + this.Field7 = vt + case *bool: + this.Field13 = vt + case *string: + this.Field14 = vt + case []byte: + this.Field15 = vt + default: + return false + } + return true +} +func (this *NinEmbeddedStructUnion) GetValue() interface{} { + if this.NidOptNative != nil { + return this.NidOptNative + } + if this.Field200 != nil { + return this.Field200 + } + if this.Field210 != nil { + return this.Field210 + } + return nil +} + +func (this *NinEmbeddedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NidOptNative: + this.NidOptNative = vt + case *NinOptNative: + this.Field200 = vt + case *bool: + this.Field210 = vt + default: + return false + } + return true +} +func (this *NinNestedStructUnion) GetValue() interface{} { + if this.Field1 != nil { + return this.Field1 + } + if this.Field2 != nil { + return this.Field2 + } + if this.Field3 != nil { + return this.Field3 + } + return nil +} + +func (this *NinNestedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NinOptNativeUnion: + this.Field1 = vt + case *NinOptStructUnion: + this.Field2 = vt + case *NinEmbeddedStructUnion: + this.Field3 = vt + default: + this.Field1 = new(NinOptNativeUnion) + if set := this.Field1.SetValue(value); set { + return true + } + this.Field1 = nil + this.Field2 = new(NinOptStructUnion) + if set := this.Field2.SetValue(value); set { + return true + } + this.Field2 = nil + this.Field3 = new(NinEmbeddedStructUnion) + if set := this.Field3.SetValue(value); set { + return true + } + this.Field3 = nil + return false + } + return true +} +func (this *Tree) GetValue() interface{} { + if this.Or != nil { + return this.Or + } + if this.And != nil { + return this.And + } + if this.Leaf != nil { + return this.Leaf + } + return nil +} + +func (this *Tree) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *OrBranch: + this.Or = vt + case *AndBranch: + this.And = vt + case *Leaf: + this.Leaf = vt + default: + return false + } + return true +} +func (this *DeepTree) GetValue() interface{} { + if this.Down != nil { + return this.Down + } + if this.And != nil { + return this.And + } + if this.Leaf != nil { + return this.Leaf + } + return nil +} + +func (this *DeepTree) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *ADeepBranch: + this.Down = vt + case *AndDeepBranch: + this.And = vt + case *DeepLeaf: + this.Leaf = vt + default: + return false + } + return true +} +func (this *CustomNameNinEmbeddedStructUnion) GetValue() interface{} { + if this.NidOptNative != nil { + return this.NidOptNative + } + if this.FieldA != nil { + return this.FieldA + } + if this.FieldB != nil { + return this.FieldB + } + return nil +} + +func (this *CustomNameNinEmbeddedStructUnion) SetValue(value interface{}) bool { + switch vt := value.(type) { + case *NidOptNative: + this.NidOptNative = vt + case *NinOptNative: + this.FieldA = vt + case *bool: + this.FieldB = vt + default: + return false + } + return true +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/thetest.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/thetest.proto new file mode 100644 index 0000000000000000000000000000000000000000..b632a33db1f927876b3fc8d0f6c54d25639af77e --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/thetest.proto @@ -0,0 +1,584 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; +package test; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.face_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; +option (gogoproto.unmarshaler_all) = false; +option (gogoproto.marshaler_all) = false; +option (gogoproto.sizer_all) = true; + +option (gogoproto.goproto_enum_stringer_all) = false; +option (gogoproto.enum_stringer_all) = true; + +option (gogoproto.unsafe_marshaler_all) = false; +option (gogoproto.unsafe_unmarshaler_all) = false; + +message NidOptNative { + optional double Field1 = 1 [(gogoproto.nullable) = false]; + optional float Field2 = 2 [(gogoproto.nullable) = false]; + optional int32 Field3 = 3 [(gogoproto.nullable) = false]; + optional int64 Field4 = 4 [(gogoproto.nullable) = false]; + optional uint32 Field5 = 5 [(gogoproto.nullable) = false]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false]; + optional sint64 Field8 = 8 [(gogoproto.nullable) = false]; + optional fixed32 Field9 = 9 [(gogoproto.nullable) = false]; + optional sfixed32 Field10 = 10 [(gogoproto.nullable) = false]; + optional fixed64 Field11 = 11 [(gogoproto.nullable) = false]; + optional sfixed64 Field12 = 12 [(gogoproto.nullable) = false]; + optional bool Field13 = 13 [(gogoproto.nullable) = false]; + optional string Field14 = 14 [(gogoproto.nullable) = false]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinOptNative { + optional double Field1 = 1; + optional float Field2 = 2; + optional int32 Field3 = 3; + optional int64 Field4 = 4; + optional uint32 Field5 = 5; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional sint64 Field8 = 8; + optional fixed32 Field9 = 9; + optional sfixed32 Field10 = 10; + optional fixed64 Field11 = 11; + optional sfixed64 Field12 = 12; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NidRepNative { + repeated double Field1 = 1 [(gogoproto.nullable) = false]; + repeated float Field2 = 2 [(gogoproto.nullable) = false]; + repeated int32 Field3 = 3 [(gogoproto.nullable) = false]; + repeated int64 Field4 = 4 [(gogoproto.nullable) = false]; + repeated uint32 Field5 = 5 [(gogoproto.nullable) = false]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false]; + repeated sint64 Field8 = 8 [(gogoproto.nullable) = false]; + repeated fixed32 Field9 = 9 [(gogoproto.nullable) = false]; + repeated sfixed32 Field10 = 10 [(gogoproto.nullable) = false]; + repeated fixed64 Field11 = 11 [(gogoproto.nullable) = false]; + repeated sfixed64 Field12 = 12 [(gogoproto.nullable) = false]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false]; + repeated string Field14 = 14 [(gogoproto.nullable) = false]; + repeated bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinRepNative { + repeated double Field1 = 1; + repeated float Field2 = 2; + repeated int32 Field3 = 3; + repeated int64 Field4 = 4; + repeated uint32 Field5 = 5; + repeated uint64 Field6 = 6; + repeated sint32 Field7 = 7; + repeated sint64 Field8 = 8; + repeated fixed32 Field9 = 9; + repeated sfixed32 Field10 = 10; + repeated fixed64 Field11 = 11; + repeated sfixed64 Field12 = 12; + repeated bool Field13 = 13; + repeated string Field14 = 14; + repeated bytes Field15 = 15; +} + +message NidRepPackedNative { + repeated double Field1 = 1 [(gogoproto.nullable) = false, packed = true]; + repeated float Field2 = 2 [(gogoproto.nullable) = false, packed = true]; + repeated int32 Field3 = 3 [(gogoproto.nullable) = false, packed = true]; + repeated int64 Field4 = 4 [(gogoproto.nullable) = false, packed = true]; + repeated uint32 Field5 = 5 [(gogoproto.nullable) = false, packed = true]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false, packed = true]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false, packed = true]; + repeated sint64 Field8 = 8 [(gogoproto.nullable) = false, packed = true]; + repeated fixed32 Field9 = 9 [(gogoproto.nullable) = false, packed = true]; + repeated sfixed32 Field10 = 10 [(gogoproto.nullable) = false, packed = true]; + repeated fixed64 Field11 = 11 [(gogoproto.nullable) = false, packed = true]; + repeated sfixed64 Field12 = 12 [(gogoproto.nullable) = false, packed = true]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false, packed = true]; +} + +message NinRepPackedNative { + repeated double Field1 = 1 [packed = true]; + repeated float Field2 = 2 [packed = true]; + repeated int32 Field3 = 3 [packed = true]; + repeated int64 Field4 = 4 [packed = true]; + repeated uint32 Field5 = 5 [packed = true]; + repeated uint64 Field6 = 6 [packed = true]; + repeated sint32 Field7 = 7 [packed = true]; + repeated sint64 Field8 = 8 [packed = true]; + repeated fixed32 Field9 = 9 [packed = true]; + repeated sfixed32 Field10 = 10 [packed = true]; + repeated fixed64 Field11 = 11 [packed = true]; + repeated sfixed64 Field12 = 12 [packed = true]; + repeated bool Field13 = 13 [packed = true]; +} + +message NidOptStruct { + optional double Field1 = 1 [(gogoproto.nullable) = false]; + optional float Field2 = 2 [(gogoproto.nullable) = false]; + optional NidOptNative Field3 = 3 [(gogoproto.nullable) = false]; + optional NinOptNative Field4 = 4 [(gogoproto.nullable) = false]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false]; + optional NidOptNative Field8 = 8 [(gogoproto.nullable) = false]; + optional bool Field13 = 13 [(gogoproto.nullable) = false]; + optional string Field14 = 14 [(gogoproto.nullable) = false]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinOptStruct { + optional double Field1 = 1; + optional float Field2 = 2; + optional NidOptNative Field3 = 3; + optional NinOptNative Field4 = 4; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional NidOptNative Field8 = 8; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NidRepStruct { + repeated double Field1 = 1 [(gogoproto.nullable) = false]; + repeated float Field2 = 2 [(gogoproto.nullable) = false]; + repeated NidOptNative Field3 = 3 [(gogoproto.nullable) = false]; + repeated NinOptNative Field4 = 4 [(gogoproto.nullable) = false]; + repeated uint64 Field6 = 6 [(gogoproto.nullable) = false]; + repeated sint32 Field7 = 7 [(gogoproto.nullable) = false]; + repeated NidOptNative Field8 = 8 [(gogoproto.nullable) = false]; + repeated bool Field13 = 13 [(gogoproto.nullable) = false]; + repeated string Field14 = 14 [(gogoproto.nullable) = false]; + repeated bytes Field15 = 15 [(gogoproto.nullable) = false]; +} + +message NinRepStruct { + repeated double Field1 = 1; + repeated float Field2 = 2; + repeated NidOptNative Field3 = 3; + repeated NinOptNative Field4 = 4; + repeated uint64 Field6 = 6; + repeated sint32 Field7 = 7; + repeated NidOptNative Field8 = 8; + repeated bool Field13 = 13; + repeated string Field14 = 14; + repeated bytes Field15 = 15; +} + +message NidEmbeddedStruct { + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NidOptNative Field200 = 200 [(gogoproto.nullable) = false]; + optional bool Field210 = 210 [(gogoproto.nullable) = false]; +} + +message NinEmbeddedStruct { + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NidOptNative Field200 = 200; + optional bool Field210 = 210; +} + +message NidNestedStruct { + optional NidOptStruct Field1 = 1 [(gogoproto.nullable) = false]; + repeated NidRepStruct Field2 = 2 [(gogoproto.nullable) = false]; +} + +message NinNestedStruct { + optional NinOptStruct Field1 = 1; + repeated NinRepStruct Field2 = 2; +} + +message NidOptCustom { + optional bytes Id = 1 [(gogoproto.customtype) = "Uuid", (gogoproto.nullable) = false]; + optional bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; +} + +message CustomDash { + optional bytes Value = 1 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom-dash-type.Bytes"]; +} + +message NinOptCustom { + optional bytes Id = 1 [(gogoproto.customtype) = "Uuid"]; + optional bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message NidRepCustom { + repeated bytes Id = 1 [(gogoproto.customtype) = "Uuid", (gogoproto.nullable) = false]; + repeated bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128", (gogoproto.nullable) = false]; +} + +message NinRepCustom { + repeated bytes Id = 1 [(gogoproto.customtype) = "Uuid"]; + repeated bytes Value = 2 [(gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message NinOptNativeUnion { + option (gogoproto.onlyone) = true; + optional double Field1 = 1; + optional float Field2 = 2; + optional int32 Field3 = 3; + optional int64 Field4 = 4; + optional uint32 Field5 = 5; + optional uint64 Field6 = 6; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NinOptStructUnion { + option (gogoproto.onlyone) = true; + optional double Field1 = 1; + optional float Field2 = 2; + optional NidOptNative Field3 = 3; + optional NinOptNative Field4 = 4; + optional uint64 Field6 = 6; + optional sint32 Field7 = 7; + optional bool Field13 = 13; + optional string Field14 = 14; + optional bytes Field15 = 15; +} + +message NinEmbeddedStructUnion { + option (gogoproto.onlyone) = true; + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NinOptNative Field200 = 200; + optional bool Field210 = 210; +} + +message NinNestedStructUnion { + option (gogoproto.onlyone) = true; + optional NinOptNativeUnion Field1 = 1; + optional NinOptStructUnion Field2 = 2; + optional NinEmbeddedStructUnion Field3 = 3; +} + +message Tree { + option (gogoproto.onlyone) = true; + optional OrBranch Or = 1; + optional AndBranch And = 2; + optional Leaf Leaf = 3; +} + +message OrBranch { + optional Tree Left = 1 [(gogoproto.nullable) = false]; + optional Tree Right = 2 [(gogoproto.nullable) = false]; +} + +message AndBranch { + optional Tree Left = 1 [(gogoproto.nullable) = false]; + optional Tree Right = 2 [(gogoproto.nullable) = false]; +} + +message Leaf { + optional int64 Value = 1 [(gogoproto.nullable) = false]; + optional string StrValue = 2 [(gogoproto.nullable) = false]; +} + +message DeepTree { + option (gogoproto.onlyone) = true; + optional ADeepBranch Down = 1; + optional AndDeepBranch And = 2; + optional DeepLeaf Leaf = 3; +} + +message ADeepBranch { + optional DeepTree Down = 2 [(gogoproto.nullable) = false]; +} + +message AndDeepBranch { + optional DeepTree Left = 1 [(gogoproto.nullable) = false]; + optional DeepTree Right = 2 [(gogoproto.nullable) = false]; +} + +message DeepLeaf { + optional Tree Tree = 1 [(gogoproto.nullable) = false]; +} + +message Nil { + +} + +enum TheTestEnum { + A = 0; + B = 1; + C = 2; +} + +message NidOptEnum { + optional TheTestEnum Field1 = 1 [(gogoproto.nullable) = false]; +} + +message NinOptEnum { + optional TheTestEnum Field1 = 1; +} + +message NidRepEnum { + repeated TheTestEnum Field1 = 1 [(gogoproto.nullable) = false]; +} + +message NinRepEnum { + repeated TheTestEnum Field1 = 1; +} + +message NinOptEnumDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional TheTestEnum Field1 = 1 [default=C]; +} + +enum AnotherTestEnum { + option (gogoproto.goproto_enum_prefix) = false; + D = 10; + E = 11; +} + +message AnotherNinOptEnum { + optional AnotherTestEnum Field1 = 1; +} + +message AnotherNinOptEnumDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional AnotherTestEnum Field1 = 1 [default=E]; +} + +message Timer { + optional sfixed64 Time1 = 1 [(gogoproto.nullable) = false]; + optional sfixed64 Time2 = 2 [(gogoproto.nullable) = false]; + optional bytes Data = 3 [(gogoproto.nullable) = false]; +} + +message MyExtendable { + option (gogoproto.face) = false; + optional int64 Field1 = 1; + extensions 100 to 199; +} + +extend MyExtendable { + optional double FieldA = 100; + optional NinOptNative FieldB = 101; + optional NinEmbeddedStruct FieldC = 102; +} + +message OtherExtenable { + option (gogoproto.face) = false; + optional int64 Field2 = 2; + extensions 14 to 16; + optional int64 Field13 = 13; + extensions 10 to 12; + optional MyExtendable M = 1; +} + +message NestedDefinition { + optional int64 Field1 = 1; + message NestedMessage { + optional fixed64 NestedField1 = 1; + optional NestedNestedMsg NNM = 2; + message NestedNestedMsg { + optional string NestedNestedField1 = 10; + } + } + enum NestedEnum { + TYPE_NESTED = 1; + } + optional NestedEnum EnumField = 2; + optional NestedMessage.NestedNestedMsg NNM = 3; + optional NestedMessage NM = 4; +} + +message NestedScope { + optional NestedDefinition.NestedMessage.NestedNestedMsg A = 1; + optional NestedDefinition.NestedEnum B = 2; + optional NestedDefinition.NestedMessage C = 3; +} + +message NinOptNativeDefault { + option (gogoproto.goproto_getters) = true; + option (gogoproto.face) = false; + optional double Field1 = 1 [default = 1234.1234]; + optional float Field2 = 2 [default = 1234.1234]; + optional int32 Field3 = 3 [default = 1234]; + optional int64 Field4 = 4 [default = 1234]; + optional uint32 Field5 = 5 [default = 1234]; + optional uint64 Field6 = 6 [default = 1234]; + optional sint32 Field7 = 7 [default = 1234]; + optional sint64 Field8 = 8 [default = 1234]; + optional fixed32 Field9 = 9 [default = 1234]; + optional sfixed32 Field10 = 10 [default = 1234]; + optional fixed64 Field11 = 11 [default = 1234]; + optional sfixed64 Field12 = 12 [default = 1234]; + optional bool Field13 = 13 [default = true]; + optional string Field14 = 14 [default = "1234"]; + optional bytes Field15 = 15; +} + +message CustomContainer { + optional NidOptCustom CustomStruct = 1 [(gogoproto.nullable) = false]; +} + +message CustomNameNidOptNative { + optional double Field1 = 1 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldB"]; + optional int32 Field3 = 3 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldC"]; + optional int64 Field4 = 4 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldD"]; + optional uint32 Field5 = 5 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldE"]; + optional uint64 Field6 = 6 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldF"]; + optional sint32 Field7 = 7 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldG"]; + optional sint64 Field8 = 8 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldH"]; + optional fixed32 Field9 = 9 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldI"]; + optional sfixed32 Field10 = 10 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldJ"]; + optional fixed64 Field11 = 11 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldK"]; + optional sfixed64 Field12 = 12 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldL"]; + optional bool Field13 = 13 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldM"]; + optional string Field14 = 14 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldN"]; + optional bytes Field15 = 15 [(gogoproto.nullable) = false, (gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinOptNative { + optional double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + optional int32 Field3 = 3 [(gogoproto.customname) = "FieldC"]; + optional int64 Field4 = 4 [(gogoproto.customname) = "FieldD"]; + optional uint32 Field5 = 5 [(gogoproto.customname) = "FieldE"]; + optional uint64 Field6 = 6 [(gogoproto.customname) = "FieldF"]; + optional sint32 Field7 = 7 [(gogoproto.customname) = "FieldG"]; + optional sint64 Field8 = 8 [(gogoproto.customname) = "FieldH"]; + optional fixed32 Field9 = 9 [(gogoproto.customname) = "FieldI"]; + optional sfixed32 Field10 = 10 [(gogoproto.customname) = "FieldJ"]; + optional fixed64 Field11 = 11 [(gogoproto.customname) = "FieldK"]; + optional sfixed64 Field12 = 12 [(gogoproto.customname) = "FielL"]; + optional bool Field13 = 13 [(gogoproto.customname) = "FieldM"]; + optional string Field14 = 14 [(gogoproto.customname) = "FieldN"]; + optional bytes Field15 = 15 [(gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinRepNative { + repeated double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + repeated float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + repeated int32 Field3 = 3 [(gogoproto.customname) = "FieldC"]; + repeated int64 Field4 = 4 [(gogoproto.customname) = "FieldD"]; + repeated uint32 Field5 = 5 [(gogoproto.customname) = "FieldE"]; + repeated uint64 Field6 = 6 [(gogoproto.customname) = "FieldF"]; + repeated sint32 Field7 = 7 [(gogoproto.customname) = "FieldG"]; + repeated sint64 Field8 = 8 [(gogoproto.customname) = "FieldH"]; + repeated fixed32 Field9 = 9 [(gogoproto.customname) = "FieldI"]; + repeated sfixed32 Field10 = 10 [(gogoproto.customname) = "FieldJ"]; + repeated fixed64 Field11 = 11 [(gogoproto.customname) = "FieldK"]; + repeated sfixed64 Field12 = 12 [(gogoproto.customname) = "FieldL"]; + repeated bool Field13 = 13 [(gogoproto.customname) = "FieldM"]; + repeated string Field14 = 14 [(gogoproto.customname) = "FieldN"]; + repeated bytes Field15 = 15 [(gogoproto.customname) = "FieldO"]; +} + +message CustomNameNinStruct { + optional double Field1 = 1 [(gogoproto.customname) = "FieldA"]; + optional float Field2 = 2 [(gogoproto.customname) = "FieldB"]; + optional NidOptNative Field3 = 3 [(gogoproto.customname) = "FieldC"]; + repeated NinOptNative Field4 = 4 [(gogoproto.customname) = "FieldD"]; + optional uint64 Field6 = 6 [(gogoproto.customname) = "FieldE"]; + optional sint32 Field7 = 7 [(gogoproto.customname) = "FieldF"]; + optional NidOptNative Field8 = 8 [(gogoproto.customname) = "FieldG"]; + optional bool Field13 = 13 [(gogoproto.customname) = "FieldH"]; + optional string Field14 = 14 [(gogoproto.customname) = "FieldI"]; + optional bytes Field15 = 15 [(gogoproto.customname) = "FieldJ"]; +} + +message CustomNameCustomType { + optional bytes Id = 1 [(gogoproto.customname) = "FieldA", (gogoproto.customtype) = "Uuid"]; + optional bytes Value = 2 [(gogoproto.customname) = "FieldB", (gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; + repeated bytes Ids = 3 [(gogoproto.customname) = "FieldC", (gogoproto.customtype) = "Uuid"]; + repeated bytes Values = 4 [(gogoproto.customname) = "FieldD", (gogoproto.customtype) = "github.com/gogo/protobuf/test/custom.Uint128"]; +} + +message CustomNameNinEmbeddedStructUnion { + option (gogoproto.onlyone) = true; + optional NidOptNative Field1 = 1 [(gogoproto.embed) = true]; + optional NinOptNative Field200 = 200 [(gogoproto.customname) = "FieldA"]; + optional bool Field210 = 210 [(gogoproto.customname) = "FieldB"]; +} + +message CustomNameEnum { + optional TheTestEnum Field1 = 1 [(gogoproto.customname) = "FieldA"]; + repeated TheTestEnum Field2 = 2 [(gogoproto.customname) = "FieldB"]; +} + +message NoExtensionsMap { + option (gogoproto.face) = false; + option (gogoproto.goproto_extensions_map) = false; + optional int64 Field1 = 1; + extensions 100 to 199; +} + +extend NoExtensionsMap { + optional double FieldA1 = 100; + optional NinOptNative FieldB1 = 101; + optional NinEmbeddedStruct FieldC1 = 102; +} + +message Unrecognized { + option (gogoproto.goproto_unrecognized) = false; + optional string Field1 = 1; +} + +message UnrecognizedWithInner { + message Inner { + option (gogoproto.goproto_unrecognized) = false; + optional uint32 Field1 = 1; + } + + repeated Inner embedded = 1; + optional string Field2 = 2; +} + +message UnrecognizedWithEmbed { + message Embedded { + option (gogoproto.goproto_unrecognized) = false; + optional uint32 Field1 = 1; + } + + optional Embedded embedded = 1 [(gogoproto.embed) = true, (gogoproto.nullable) = false]; + optional string Field2 = 2; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/thetestpb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/thetestpb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..1080c1fecb06951c828a56e3e463fec2df442e8e --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/thetestpb_test.go @@ -0,0 +1,12939 @@ +// Code generated by protoc-gen-gogo. +// source: thetest.proto +// DO NOT EDIT! + +/* +Package test is a generated protocol buffer package. + +It is generated from these files: + thetest.proto + +It has these top-level messages: + NidOptNative + NinOptNative + NidRepNative + NinRepNative + NidRepPackedNative + NinRepPackedNative + NidOptStruct + NinOptStruct + NidRepStruct + NinRepStruct + NidEmbeddedStruct + NinEmbeddedStruct + NidNestedStruct + NinNestedStruct + NidOptCustom + CustomDash + NinOptCustom + NidRepCustom + NinRepCustom + NinOptNativeUnion + NinOptStructUnion + NinEmbeddedStructUnion + NinNestedStructUnion + Tree + OrBranch + AndBranch + Leaf + DeepTree + ADeepBranch + AndDeepBranch + DeepLeaf + Nil + NidOptEnum + NinOptEnum + NidRepEnum + NinRepEnum + NinOptEnumDefault + AnotherNinOptEnum + AnotherNinOptEnumDefault + Timer + MyExtendable + OtherExtenable + NestedDefinition + NestedScope + NinOptNativeDefault + CustomContainer + CustomNameNidOptNative + CustomNameNinOptNative + CustomNameNinRepNative + CustomNameNinStruct + CustomNameCustomType + CustomNameNinEmbeddedStructUnion + CustomNameEnum + NoExtensionsMap + Unrecognized + UnrecognizedWithInner + UnrecognizedWithEmbed +*/ +package test + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestNidOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepPackedNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidRepPackedNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepPackedNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepPackedNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepPackedNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepPackedNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepPackedNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinRepPackedNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepPackedNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepPackedNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepPackedNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepPackedNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidOptStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidRepStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinRepStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidEmbeddedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidEmbeddedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidEmbeddedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidEmbeddedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidEmbeddedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidEmbeddedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinEmbeddedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinEmbeddedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinEmbeddedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidNestedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidNestedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidNestedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidNestedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidNestedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidNestedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinNestedStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinNestedStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinNestedStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidOptCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomDashProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomDashProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomDash, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomDash(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomDashProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomDash(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomDash{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidRepCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepCustomProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinRepCustomProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepCustom, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepCustomProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepCustom(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepCustom{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptNativeUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNativeUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNativeUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinEmbeddedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinEmbeddedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinEmbeddedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinNestedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinNestedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinNestedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinNestedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinNestedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestTreeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkTreeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Tree, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkTreeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTree(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Tree{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestOrBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkOrBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OrBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedOrBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkOrBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOrBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &OrBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAndBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAndBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAndBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AndBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestLeafProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkLeafProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Leaf, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkLeafProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedLeaf(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Leaf{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepTreeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkDeepTreeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepTree, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedDeepTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkDeepTreeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepTree(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &DeepTree{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestADeepBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkADeepBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*ADeepBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedADeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkADeepBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedADeepBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &ADeepBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndDeepBranchProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAndDeepBranchProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndDeepBranch, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAndDeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAndDeepBranchProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAndDeepBranch(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AndDeepBranch{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepLeafProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkDeepLeafProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepLeaf, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedDeepLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkDeepLeafProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedDeepLeaf(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &DeepLeaf{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNilProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNilProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nil, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNil(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNilProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNil(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Nil{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNidRepEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNidRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNidRepEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNidRepEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NidRepEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinRepEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinRepEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinRepEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinRepEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptEnumDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnumDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptEnumDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptEnumDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptEnumDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAnotherNinOptEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAnotherNinOptEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AnotherNinOptEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkAnotherNinOptEnumDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnumDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkAnotherNinOptEnumDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedAnotherNinOptEnumDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &AnotherNinOptEnumDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestTimerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkTimerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Timer, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedTimer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkTimerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedTimer(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Timer{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestMyExtendableProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkMyExtendableProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MyExtendable, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedMyExtendable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkMyExtendableProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedMyExtendable(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &MyExtendable{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestOtherExtenableProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkOtherExtenableProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OtherExtenable, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedOtherExtenable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkOtherExtenableProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedOtherExtenable(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &OtherExtenable{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinitionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNestedDefinitionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinitionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessageProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNestedDefinition_NestedMessageProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinition_NestedMessageProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition_NestedMessage{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedScopeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNestedScopeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedScope, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNestedScope(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNestedScopeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNestedScope(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NestedScope{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeDefaultProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNinOptNativeDefaultProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeDefault, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNinOptNativeDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNinOptNativeDefaultProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNinOptNativeDefault(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NinOptNativeDefault{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomContainerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomContainerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomContainer, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomContainer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomContainerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomContainer(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomContainer{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNidOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameNidOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNidOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNidOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNidOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNidOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinOptNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameNinOptNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinOptNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinOptNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinOptNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinOptNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinRepNativeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameNinRepNativeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinRepNative, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinRepNativeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinRepNative(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinRepNative{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinStructProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameNinStructProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinStruct, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinStructProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinStruct(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinStruct{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameCustomTypeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameCustomTypeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameCustomType, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameCustomType(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameCustomTypeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameCustomType(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameCustomType{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinEmbeddedStructUnionProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameNinEmbeddedStructUnionProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinEmbeddedStructUnion, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameNinEmbeddedStructUnionProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameNinEmbeddedStructUnion{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameEnumProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkCustomNameEnumProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameEnum, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedCustomNameEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkCustomNameEnumProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedCustomNameEnum(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &CustomNameEnum{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNoExtensionsMapProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkNoExtensionsMapProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NoExtensionsMap, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedNoExtensionsMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkNoExtensionsMapProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedNoExtensionsMap(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &NoExtensionsMap{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkUnrecognizedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Unrecognized, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognized(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognized(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Unrecognized{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInnerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkUnrecognizedWithInnerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithInnerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithInner{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInner_InnerProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkUnrecognizedWithInner_InnerProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner_Inner, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithInner_InnerProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithInner_Inner(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithInner_Inner{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkUnrecognizedWithEmbedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithEmbedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithEmbed{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbed_EmbeddedProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed_Embedded, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &UnrecognizedWithEmbed_Embedded{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepPackedNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepPackedNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepPackedNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepPackedNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidEmbeddedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidEmbeddedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinEmbeddedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidNestedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidNestedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinNestedStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomDashJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomDash{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepCustomJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepCustom{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinEmbeddedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinEmbeddedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinNestedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinNestedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTreeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Tree{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOrBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OrBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAndBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestLeafJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Leaf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestDeepTreeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepTree{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestADeepBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &ADeepBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAndDeepBranchJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AndDeepBranch{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestDeepLeafJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &DeepLeaf{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNilJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Nil{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidRepEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NidRepEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinRepEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinRepEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptEnumDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptEnumDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAnotherNinOptEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAnotherNinOptEnumDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &AnotherNinOptEnumDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestTimerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Timer{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestMyExtendableJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &MyExtendable{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOtherExtenableJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OtherExtenable{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinitionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinition_NestedMessageJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNestedScopeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NestedScope{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNinOptNativeDefaultJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NinOptNativeDefault{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomContainerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomContainer{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNidOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNidOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinOptNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinOptNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinRepNativeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinRepNative{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinStructJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinStruct{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameCustomTypeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameCustomType{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCustomNameEnumJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &CustomNameEnum{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNoExtensionsMapJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NoExtensionsMap{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Unrecognized{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithInnerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithInner_InnerJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithInner_Inner{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithEmbedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnrecognizedWithEmbed_EmbeddedJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNidOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepPackedNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepPackedNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepPackedNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepPackedNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidEmbeddedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidEmbeddedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidNestedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidNestedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomDashProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomDashProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepCustomProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepCustomProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinEmbeddedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinNestedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTreeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTreeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOrBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOrBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestLeafProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestLeafProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepTreeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepTreeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestADeepBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestADeepBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndDeepBranchProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAndDeepBranchProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepLeafProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDeepLeafProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNilProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNilProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNidRepEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinRepEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptEnumDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAnotherNinOptEnumDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTimerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestTimerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMyExtendableProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestMyExtendableProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOtherExtenableProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOtherExtenableProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinitionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinitionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessageProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessageProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedScopeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNestedScopeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeDefaultProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNinOptNativeDefaultProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomContainerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomContainerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNidOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNidOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinOptNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinOptNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinRepNativeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinRepNativeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinStructProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinStructProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameCustomTypeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameCustomTypeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinEmbeddedStructUnionProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameNinEmbeddedStructUnionProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameEnumProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCustomNameEnumProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNoExtensionsMapProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNoExtensionsMapProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInnerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInnerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInner_InnerProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithInner_InnerProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedWithEmbed_EmbeddedProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestThetestDescription(t *testing.T) { + ThetestDescription() +} +func TestNidOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepPackedNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepPackedNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepPackedNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidEmbeddedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinEmbeddedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinEmbeddedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidNestedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinNestedStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinNestedStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomDashVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomDash{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepCustomVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepCustom{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNativeUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinNestedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinNestedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTreeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Tree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOrBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OrBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAndBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AndBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestLeafVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Leaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestDeepTreeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &DeepTree{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestADeepBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &ADeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAndDeepBranchVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AndDeepBranch{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestDeepLeafVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &DeepLeaf{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNilVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Nil{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidRepEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NidRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinRepEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinRepEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptEnumDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAnotherNinOptEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AnotherNinOptEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAnotherNinOptEnumDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &AnotherNinOptEnumDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestTimerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Timer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestMyExtendableVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &MyExtendable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOtherExtenableVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OtherExtenable{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinitionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinition_NestedMessageVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition_NestedMessage{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedDefinition_NestedMessage_NestedNestedMsg{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNestedScopeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NestedScope{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNinOptNativeDefaultVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NinOptNativeDefault{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomContainerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomContainer{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNidOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNidOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinOptNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinOptNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinRepNativeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinRepNative{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinStructVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinStruct{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameCustomTypeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameCustomType{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameNinEmbeddedStructUnionVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameNinEmbeddedStructUnion{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCustomNameEnumVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &CustomNameEnum{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNoExtensionsMapVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NoExtensionsMap{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Unrecognized{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithInnerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithInner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithInner_InnerVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithInner_Inner{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithEmbedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithEmbed{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnrecognizedWithEmbed_EmbeddedVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnrecognizedWithEmbed_Embedded{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNidOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepPackedNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepPackedNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidEmbeddedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidNestedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinNestedStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomDashFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepCustomFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptNativeUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinNestedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestTreeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestOrBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAndBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestLeafFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestDeepTreeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestADeepBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAndDeepBranchFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestDeepLeafFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNilFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidRepEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNinRepEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestAnotherNinOptEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestTimerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinitionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinition_NestedMessageFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNestedScopeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomContainerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNidOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinOptNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinRepNativeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinStructFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameCustomTypeFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestCustomNameEnumFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithInnerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithInner_InnerFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithEmbedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestUnrecognizedWithEmbed_EmbeddedFace(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + msg := p.TestProto() + if !p.Equal(msg) { + t.Fatalf("%#v !Face Equal %#v", msg, p) + } +} +func TestNidOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepPackedNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepPackedNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidEmbeddedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinEmbeddedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidNestedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinNestedStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomDashGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepCustomGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinEmbeddedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinNestedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTreeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOrBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAndBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestLeafGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestDeepTreeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestADeepBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAndDeepBranchGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestDeepLeafGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNilGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidRepEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinRepEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptEnumDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAnotherNinOptEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAnotherNinOptEnumDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestTimerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestMyExtendableGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOtherExtenableGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinitionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinition_NestedMessageGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNestedScopeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNinOptNativeDefaultGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomContainerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNidOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinOptNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinRepNativeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinStructGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameCustomTypeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameNinEmbeddedStructUnionGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCustomNameEnumGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNoExtensionsMapGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithInnerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithInner_InnerGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithEmbedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnrecognizedWithEmbed_EmbeddedGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNidOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepPackedNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepPackedNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepPackedNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepPackedNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepPackedNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepPackedNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepPackedNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepPackedNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepPackedNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidEmbeddedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidEmbeddedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidEmbeddedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidEmbeddedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinEmbeddedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinEmbeddedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidNestedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidNestedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidNestedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidNestedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinNestedStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinNestedStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomDashSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomDash(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomDashSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomDash, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomDash(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepCustomSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepCustom(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepCustomSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepCustom, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepCustom(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNativeUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinEmbeddedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinEmbeddedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinEmbeddedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinNestedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinNestedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinNestedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinNestedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinNestedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestTreeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTree(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkTreeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Tree, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestOrBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOrBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkOrBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OrBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedOrBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAndBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAndBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestLeafSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedLeaf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkLeafSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Leaf, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepTreeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepTree(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkDeepTreeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepTree, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedDeepTree(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestADeepBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedADeepBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkADeepBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*ADeepBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedADeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAndDeepBranchSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAndDeepBranch(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAndDeepBranchSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AndDeepBranch, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAndDeepBranch(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestDeepLeafSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedDeepLeaf(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkDeepLeafSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*DeepLeaf, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedDeepLeaf(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNilSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNil(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNilSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Nil, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNil(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidRepEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNidRepEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNidRepEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NidRepEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNidRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinRepEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinRepEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinRepEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinRepEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinRepEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptEnumDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptEnumDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptEnumDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptEnumDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAnotherNinOptEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestAnotherNinOptEnumDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedAnotherNinOptEnumDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkAnotherNinOptEnumDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*AnotherNinOptEnumDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedAnotherNinOptEnumDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestTimerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedTimer(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkTimerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Timer, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedTimer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestMyExtendableSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedMyExtendable(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkMyExtendableSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*MyExtendable, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedMyExtendable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestOtherExtenableSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOtherExtenable(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkOtherExtenableSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*OtherExtenable, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedOtherExtenable(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinitionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinitionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessageSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinition_NestedMessageSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedDefinition_NestedMessage_NestedNestedMsgSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedDefinition_NestedMessage_NestedNestedMsgSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedDefinition_NestedMessage_NestedNestedMsg, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNestedScopeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNestedScope(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNestedScopeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NestedScope, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNestedScope(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNinOptNativeDefaultSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNinOptNativeDefault(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNinOptNativeDefaultSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NinOptNativeDefault, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNinOptNativeDefault(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomContainerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomContainer(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomContainerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomContainer, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomContainer(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNidOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNidOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNidOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNidOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNidOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinOptNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinOptNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinOptNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinOptNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinOptNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinRepNativeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinRepNative(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinRepNativeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinRepNative, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinRepNative(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinStructSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinStruct(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinStructSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinStruct, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinStruct(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameCustomTypeSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameCustomType(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameCustomTypeSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameCustomType, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameCustomType(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameNinEmbeddedStructUnionSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameNinEmbeddedStructUnionSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameNinEmbeddedStructUnion, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestCustomNameEnumSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedCustomNameEnum(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkCustomNameEnumSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*CustomNameEnum, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedCustomNameEnum(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNoExtensionsMapSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNoExtensionsMap(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkNoExtensionsMapSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*NoExtensionsMap, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedNoExtensionsMap(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognized(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Unrecognized, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognized(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInnerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithInnerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithInner_InnerSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithInner_InnerSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithInner_Inner, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithInner_Inner(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithEmbedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestUnrecognizedWithEmbed_EmbeddedSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func BenchmarkUnrecognizedWithEmbed_EmbeddedSize(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*UnrecognizedWithEmbed_Embedded, 1000) + for i := 0; i < 1000; i++ { + pops[i] = NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += pops[i%1000].Size() + } + b.SetBytes(int64(total / b.N)) +} + +func TestNidOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepPackedNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepPackedNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepPackedNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepPackedNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidEmbeddedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidEmbeddedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinEmbeddedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidNestedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidNestedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinNestedStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomDashStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomDash(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepCustomStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepCustom(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinEmbeddedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinNestedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTreeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOrBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOrBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAndBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestLeafStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedLeaf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestDeepTreeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestADeepBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedADeepBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAndDeepBranchStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAndDeepBranch(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestDeepLeafStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepLeaf(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNilStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNil(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNidRepEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNidRepEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinRepEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinRepEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptEnumDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptEnumDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAnotherNinOptEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAnotherNinOptEnumDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedAnotherNinOptEnumDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestTimerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTimer(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestMyExtendableStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedMyExtendable(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOtherExtenableStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOtherExtenable(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinitionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinition_NestedMessageStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedDefinition_NestedMessage_NestedNestedMsgStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedDefinition_NestedMessage_NestedNestedMsg(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNestedScopeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNestedScope(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeDefaultStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeDefault(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomContainerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomContainer(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNidOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNidOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinOptNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinOptNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinRepNativeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinRepNative(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinStructStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinStruct(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameCustomTypeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameCustomType(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameNinEmbeddedStructUnionStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCustomNameEnumStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameEnum(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNoExtensionsMapStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNoExtensionsMap(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognized(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithInnerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithInner_InnerStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithInner_Inner(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithEmbedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnrecognizedWithEmbed_EmbeddedStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnrecognizedWithEmbed_Embedded(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestNinOptNativeUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptNativeUnion(popr, true) + v := p.GetValue() + msg := &NinOptNativeUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinOptStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinOptStructUnion(popr, true) + v := p.GetValue() + msg := &NinOptStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinEmbeddedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinEmbeddedStructUnion(popr, true) + v := p.GetValue() + msg := &NinEmbeddedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestNinNestedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNinNestedStructUnion(popr, true) + v := p.GetValue() + msg := &NinNestedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestTreeOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedTree(popr, true) + v := p.GetValue() + msg := &Tree{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestDeepTreeOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedDeepTree(popr, true) + v := p.GetValue() + msg := &DeepTree{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} +func TestCustomNameNinEmbeddedStructUnionOnlyOne(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedCustomNameNinEmbeddedStructUnion(popr, true) + v := p.GetValue() + msg := &CustomNameNinEmbeddedStructUnion{} + if !msg.SetValue(v) { + t.Fatalf("OnlyOne: Could not set Value") + } + if !p.Equal(msg) { + t.Fatalf("%#v !OnlyOne Equal %#v", msg, p) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unmarshalmerge/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unmarshalmerge/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..66ea13efbe462325536969ea516e5821df6083dc --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unmarshalmerge/Makefile @@ -0,0 +1,30 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. unmarshalmerge.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unmarshalmerge/unmarshalmerge.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unmarshalmerge/unmarshalmerge.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..359fcd5e5a60d7f108e3cb08607d7006b55c929a --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unmarshalmerge/unmarshalmerge.pb.go @@ -0,0 +1,1604 @@ +// Code generated by protoc-gen-gogo. +// source: unmarshalmerge.proto +// DO NOT EDIT! + +/* + Package unmarshalmerge is a generated protocol buffer package. + + It is generated from these files: + unmarshalmerge.proto + + It has these top-level messages: + Big + BigUnsafe + Sub + IntMerge +*/ +package unmarshalmerge + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Big struct { + Sub *Sub `protobuf:"bytes,1,opt,name=Sub" json:"Sub,omitempty"` + Number *int64 `protobuf:"varint,2,opt,name=Number" json:"Number,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Big) Reset() { *m = Big{} } +func (*Big) ProtoMessage() {} + +func (m *Big) GetSub() *Sub { + if m != nil { + return m.Sub + } + return nil +} + +func (m *Big) GetNumber() int64 { + if m != nil && m.Number != nil { + return *m.Number + } + return 0 +} + +type BigUnsafe struct { + Sub *Sub `protobuf:"bytes,1,opt,name=Sub" json:"Sub,omitempty"` + Number *int64 `protobuf:"varint,2,opt,name=Number" json:"Number,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *BigUnsafe) Reset() { *m = BigUnsafe{} } +func (*BigUnsafe) ProtoMessage() {} + +func (m *BigUnsafe) GetSub() *Sub { + if m != nil { + return m.Sub + } + return nil +} + +func (m *BigUnsafe) GetNumber() int64 { + if m != nil && m.Number != nil { + return *m.Number + } + return 0 +} + +type Sub struct { + SubNumber *int64 `protobuf:"varint,1,opt,name=SubNumber" json:"SubNumber,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Sub) Reset() { *m = Sub{} } +func (*Sub) ProtoMessage() {} + +func (m *Sub) GetSubNumber() int64 { + if m != nil && m.SubNumber != nil { + return *m.SubNumber + } + return 0 +} + +type IntMerge struct { + Int64 int64 `protobuf:"varint,1,req,name=Int64" json:"Int64"` + Int32 int32 `protobuf:"varint,2,opt,name=Int32" json:"Int32"` + Sint32 int32 `protobuf:"zigzag32,3,req,name=Sint32" json:"Sint32"` + Sint64 int64 `protobuf:"zigzag64,4,opt,name=Sint64" json:"Sint64"` + Uint64 uint64 `protobuf:"varint,5,opt,name=Uint64" json:"Uint64"` + Uint32 uint32 `protobuf:"varint,6,req,name=Uint32" json:"Uint32"` + Fixed64 uint64 `protobuf:"fixed64,7,opt,name=Fixed64" json:"Fixed64"` + Fixed32 uint32 `protobuf:"fixed32,8,opt,name=Fixed32" json:"Fixed32"` + Sfixed32 int32 `protobuf:"fixed32,9,req,name=Sfixed32" json:"Sfixed32"` + Sfixed64 int64 `protobuf:"fixed64,10,opt,name=Sfixed64" json:"Sfixed64"` + Bool bool `protobuf:"varint,11,opt,name=Bool" json:"Bool"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *IntMerge) Reset() { *m = IntMerge{} } +func (*IntMerge) ProtoMessage() {} + +func (m *IntMerge) GetInt64() int64 { + if m != nil { + return m.Int64 + } + return 0 +} + +func (m *IntMerge) GetInt32() int32 { + if m != nil { + return m.Int32 + } + return 0 +} + +func (m *IntMerge) GetSint32() int32 { + if m != nil { + return m.Sint32 + } + return 0 +} + +func (m *IntMerge) GetSint64() int64 { + if m != nil { + return m.Sint64 + } + return 0 +} + +func (m *IntMerge) GetUint64() uint64 { + if m != nil { + return m.Uint64 + } + return 0 +} + +func (m *IntMerge) GetUint32() uint32 { + if m != nil { + return m.Uint32 + } + return 0 +} + +func (m *IntMerge) GetFixed64() uint64 { + if m != nil { + return m.Fixed64 + } + return 0 +} + +func (m *IntMerge) GetFixed32() uint32 { + if m != nil { + return m.Fixed32 + } + return 0 +} + +func (m *IntMerge) GetSfixed32() int32 { + if m != nil { + return m.Sfixed32 + } + return 0 +} + +func (m *IntMerge) GetSfixed64() int64 { + if m != nil { + return m.Sfixed64 + } + return 0 +} + +func (m *IntMerge) GetBool() bool { + if m != nil { + return m.Bool + } + return false +} + +func (this *Big) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Big) + if !ok { + return fmt.Errorf("that is not of type *Big") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Big but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Bigbut is not nil && this == nil") + } + if !this.Sub.Equal(that1.Sub) { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) + } + if this.Number != nil && that1.Number != nil { + if *this.Number != *that1.Number { + return fmt.Errorf("Number this(%v) Not Equal that(%v)", *this.Number, *that1.Number) + } + } else if this.Number != nil { + return fmt.Errorf("this.Number == nil && that.Number != nil") + } else if that1.Number != nil { + return fmt.Errorf("Number this(%v) Not Equal that(%v)", this.Number, that1.Number) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Big) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Big) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Sub.Equal(that1.Sub) { + return false + } + if this.Number != nil && that1.Number != nil { + if *this.Number != *that1.Number { + return false + } + } else if this.Number != nil { + return false + } else if that1.Number != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *BigUnsafe) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*BigUnsafe) + if !ok { + return fmt.Errorf("that is not of type *BigUnsafe") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *BigUnsafe but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *BigUnsafebut is not nil && this == nil") + } + if !this.Sub.Equal(that1.Sub) { + return fmt.Errorf("Sub this(%v) Not Equal that(%v)", this.Sub, that1.Sub) + } + if this.Number != nil && that1.Number != nil { + if *this.Number != *that1.Number { + return fmt.Errorf("Number this(%v) Not Equal that(%v)", *this.Number, *that1.Number) + } + } else if this.Number != nil { + return fmt.Errorf("this.Number == nil && that.Number != nil") + } else if that1.Number != nil { + return fmt.Errorf("Number this(%v) Not Equal that(%v)", this.Number, that1.Number) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *BigUnsafe) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*BigUnsafe) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.Sub.Equal(that1.Sub) { + return false + } + if this.Number != nil && that1.Number != nil { + if *this.Number != *that1.Number { + return false + } + } else if this.Number != nil { + return false + } else if that1.Number != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Sub) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*Sub) + if !ok { + return fmt.Errorf("that is not of type *Sub") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *Sub but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Subbut is not nil && this == nil") + } + if this.SubNumber != nil && that1.SubNumber != nil { + if *this.SubNumber != *that1.SubNumber { + return fmt.Errorf("SubNumber this(%v) Not Equal that(%v)", *this.SubNumber, *that1.SubNumber) + } + } else if this.SubNumber != nil { + return fmt.Errorf("this.SubNumber == nil && that.SubNumber != nil") + } else if that1.SubNumber != nil { + return fmt.Errorf("SubNumber this(%v) Not Equal that(%v)", this.SubNumber, that1.SubNumber) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *Sub) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Sub) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.SubNumber != nil && that1.SubNumber != nil { + if *this.SubNumber != *that1.SubNumber { + return false + } + } else if this.SubNumber != nil { + return false + } else if that1.SubNumber != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *IntMerge) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*IntMerge) + if !ok { + return fmt.Errorf("that is not of type *IntMerge") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *IntMerge but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *IntMergebut is not nil && this == nil") + } + if this.Int64 != that1.Int64 { + return fmt.Errorf("Int64 this(%v) Not Equal that(%v)", this.Int64, that1.Int64) + } + if this.Int32 != that1.Int32 { + return fmt.Errorf("Int32 this(%v) Not Equal that(%v)", this.Int32, that1.Int32) + } + if this.Sint32 != that1.Sint32 { + return fmt.Errorf("Sint32 this(%v) Not Equal that(%v)", this.Sint32, that1.Sint32) + } + if this.Sint64 != that1.Sint64 { + return fmt.Errorf("Sint64 this(%v) Not Equal that(%v)", this.Sint64, that1.Sint64) + } + if this.Uint64 != that1.Uint64 { + return fmt.Errorf("Uint64 this(%v) Not Equal that(%v)", this.Uint64, that1.Uint64) + } + if this.Uint32 != that1.Uint32 { + return fmt.Errorf("Uint32 this(%v) Not Equal that(%v)", this.Uint32, that1.Uint32) + } + if this.Fixed64 != that1.Fixed64 { + return fmt.Errorf("Fixed64 this(%v) Not Equal that(%v)", this.Fixed64, that1.Fixed64) + } + if this.Fixed32 != that1.Fixed32 { + return fmt.Errorf("Fixed32 this(%v) Not Equal that(%v)", this.Fixed32, that1.Fixed32) + } + if this.Sfixed32 != that1.Sfixed32 { + return fmt.Errorf("Sfixed32 this(%v) Not Equal that(%v)", this.Sfixed32, that1.Sfixed32) + } + if this.Sfixed64 != that1.Sfixed64 { + return fmt.Errorf("Sfixed64 this(%v) Not Equal that(%v)", this.Sfixed64, that1.Sfixed64) + } + if this.Bool != that1.Bool { + return fmt.Errorf("Bool this(%v) Not Equal that(%v)", this.Bool, that1.Bool) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *IntMerge) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*IntMerge) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Int64 != that1.Int64 { + return false + } + if this.Int32 != that1.Int32 { + return false + } + if this.Sint32 != that1.Sint32 { + return false + } + if this.Sint64 != that1.Sint64 { + return false + } + if this.Uint64 != that1.Uint64 { + return false + } + if this.Uint32 != that1.Uint32 { + return false + } + if this.Fixed64 != that1.Fixed64 { + return false + } + if this.Fixed32 != that1.Fixed32 { + return false + } + if this.Sfixed32 != that1.Sfixed32 { + return false + } + if this.Sfixed64 != that1.Sfixed64 { + return false + } + if this.Bool != that1.Bool { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *Big) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&unmarshalmerge.Big{") + if this.Sub != nil { + s = append(s, "Sub: "+fmt.Sprintf("%#v", this.Sub)+",\n") + } + if this.Number != nil { + s = append(s, "Number: "+valueToGoStringUnmarshalmerge(this.Number, "int64")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *BigUnsafe) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&unmarshalmerge.BigUnsafe{") + if this.Sub != nil { + s = append(s, "Sub: "+fmt.Sprintf("%#v", this.Sub)+",\n") + } + if this.Number != nil { + s = append(s, "Number: "+valueToGoStringUnmarshalmerge(this.Number, "int64")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *Sub) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&unmarshalmerge.Sub{") + if this.SubNumber != nil { + s = append(s, "SubNumber: "+valueToGoStringUnmarshalmerge(this.SubNumber, "int64")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *IntMerge) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 15) + s = append(s, "&unmarshalmerge.IntMerge{") + s = append(s, "Int64: "+fmt.Sprintf("%#v", this.Int64)+",\n") + s = append(s, "Int32: "+fmt.Sprintf("%#v", this.Int32)+",\n") + s = append(s, "Sint32: "+fmt.Sprintf("%#v", this.Sint32)+",\n") + s = append(s, "Sint64: "+fmt.Sprintf("%#v", this.Sint64)+",\n") + s = append(s, "Uint64: "+fmt.Sprintf("%#v", this.Uint64)+",\n") + s = append(s, "Uint32: "+fmt.Sprintf("%#v", this.Uint32)+",\n") + s = append(s, "Fixed64: "+fmt.Sprintf("%#v", this.Fixed64)+",\n") + s = append(s, "Fixed32: "+fmt.Sprintf("%#v", this.Fixed32)+",\n") + s = append(s, "Sfixed32: "+fmt.Sprintf("%#v", this.Sfixed32)+",\n") + s = append(s, "Sfixed64: "+fmt.Sprintf("%#v", this.Sfixed64)+",\n") + s = append(s, "Bool: "+fmt.Sprintf("%#v", this.Bool)+",\n") + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringUnmarshalmerge(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringUnmarshalmerge(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func NewPopulatedBig(r randyUnmarshalmerge, easy bool) *Big { + this := &Big{} + if r.Intn(10) != 0 { + this.Sub = NewPopulatedSub(r, easy) + } + if r.Intn(10) != 0 { + v1 := int64(r.Int63()) + if r.Intn(2) == 0 { + v1 *= -1 + } + this.Number = &v1 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedUnmarshalmerge(r, 3) + } + return this +} + +func NewPopulatedBigUnsafe(r randyUnmarshalmerge, easy bool) *BigUnsafe { + this := &BigUnsafe{} + if r.Intn(10) != 0 { + this.Sub = NewPopulatedSub(r, easy) + } + if r.Intn(10) != 0 { + v2 := int64(r.Int63()) + if r.Intn(2) == 0 { + v2 *= -1 + } + this.Number = &v2 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedUnmarshalmerge(r, 3) + } + return this +} + +func NewPopulatedSub(r randyUnmarshalmerge, easy bool) *Sub { + this := &Sub{} + if r.Intn(10) != 0 { + v3 := int64(r.Int63()) + if r.Intn(2) == 0 { + v3 *= -1 + } + this.SubNumber = &v3 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedUnmarshalmerge(r, 2) + } + return this +} + +func NewPopulatedIntMerge(r randyUnmarshalmerge, easy bool) *IntMerge { + this := &IntMerge{} + this.Int64 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Int64 *= -1 + } + this.Int32 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Int32 *= -1 + } + this.Sint32 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sint32 *= -1 + } + this.Sint64 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sint64 *= -1 + } + this.Uint64 = uint64(uint64(r.Uint32())) + this.Uint32 = uint32(r.Uint32()) + this.Fixed64 = uint64(uint64(r.Uint32())) + this.Fixed32 = uint32(r.Uint32()) + this.Sfixed32 = int32(r.Int31()) + if r.Intn(2) == 0 { + this.Sfixed32 *= -1 + } + this.Sfixed64 = int64(r.Int63()) + if r.Intn(2) == 0 { + this.Sfixed64 *= -1 + } + this.Bool = bool(bool(r.Intn(2) == 0)) + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedUnmarshalmerge(r, 12) + } + return this +} + +type randyUnmarshalmerge interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneUnmarshalmerge(r randyUnmarshalmerge) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringUnmarshalmerge(r randyUnmarshalmerge) string { + v4 := r.Intn(100) + tmps := make([]rune, v4) + for i := 0; i < v4; i++ { + tmps[i] = randUTF8RuneUnmarshalmerge(r) + } + return string(tmps) +} +func randUnrecognizedUnmarshalmerge(r randyUnmarshalmerge, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldUnmarshalmerge(data, r, fieldNumber, wire) + } + return data +} +func randFieldUnmarshalmerge(data []byte, r randyUnmarshalmerge, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateUnmarshalmerge(data, uint64(key)) + v5 := r.Int63() + if r.Intn(2) == 0 { + v5 *= -1 + } + data = encodeVarintPopulateUnmarshalmerge(data, uint64(v5)) + case 1: + data = encodeVarintPopulateUnmarshalmerge(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateUnmarshalmerge(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateUnmarshalmerge(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateUnmarshalmerge(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateUnmarshalmerge(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (this *Big) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Big{`, + `Sub:` + strings.Replace(fmt.Sprintf("%v", this.Sub), "Sub", "Sub", 1) + `,`, + `Number:` + valueToStringUnmarshalmerge(this.Number) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *BigUnsafe) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&BigUnsafe{`, + `Sub:` + strings.Replace(fmt.Sprintf("%v", this.Sub), "Sub", "Sub", 1) + `,`, + `Number:` + valueToStringUnmarshalmerge(this.Number) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *Sub) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Sub{`, + `SubNumber:` + valueToStringUnmarshalmerge(this.SubNumber) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *IntMerge) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&IntMerge{`, + `Int64:` + fmt.Sprintf("%v", this.Int64) + `,`, + `Int32:` + fmt.Sprintf("%v", this.Int32) + `,`, + `Sint32:` + fmt.Sprintf("%v", this.Sint32) + `,`, + `Sint64:` + fmt.Sprintf("%v", this.Sint64) + `,`, + `Uint64:` + fmt.Sprintf("%v", this.Uint64) + `,`, + `Uint32:` + fmt.Sprintf("%v", this.Uint32) + `,`, + `Fixed64:` + fmt.Sprintf("%v", this.Fixed64) + `,`, + `Fixed32:` + fmt.Sprintf("%v", this.Fixed32) + `,`, + `Sfixed32:` + fmt.Sprintf("%v", this.Sfixed32) + `,`, + `Sfixed64:` + fmt.Sprintf("%v", this.Sfixed64) + `,`, + `Bool:` + fmt.Sprintf("%v", this.Bool) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringUnmarshalmerge(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Big) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnmarshalmerge + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Big: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Big: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sub", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnmarshalmerge + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthUnmarshalmerge + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Sub == nil { + m.Sub = &Sub{} + } + if err := m.Sub.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnmarshalmerge + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Number = &v + default: + iNdEx = preIndex + skippy, err := skipUnmarshalmerge(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthUnmarshalmerge + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Sub) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnmarshalmerge + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Sub: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Sub: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SubNumber", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnmarshalmerge + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.SubNumber = &v + default: + iNdEx = preIndex + skippy, err := skipUnmarshalmerge(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthUnmarshalmerge + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *IntMerge) Unmarshal(data []byte) error { + var hasFields [1]uint64 + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnmarshalmerge + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: IntMerge: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IntMerge: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int64", wireType) + } + m.Int64 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnmarshalmerge + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Int64 |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + hasFields[0] |= uint64(0x00000001) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32", wireType) + } + m.Int32 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnmarshalmerge + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Int32 |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint32", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnmarshalmerge + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31)) + m.Sint32 = v + hasFields[0] |= uint64(0x00000002) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Sint64", wireType) + } + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnmarshalmerge + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63) + m.Sint64 = int64(v) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint64", wireType) + } + m.Uint64 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnmarshalmerge + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Uint64 |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Uint32", wireType) + } + m.Uint32 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnmarshalmerge + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Uint32 |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + hasFields[0] |= uint64(0x00000004) + case 7: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed64", wireType) + } + m.Fixed64 = 0 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + m.Fixed64 = uint64(data[iNdEx-8]) + m.Fixed64 |= uint64(data[iNdEx-7]) << 8 + m.Fixed64 |= uint64(data[iNdEx-6]) << 16 + m.Fixed64 |= uint64(data[iNdEx-5]) << 24 + m.Fixed64 |= uint64(data[iNdEx-4]) << 32 + m.Fixed64 |= uint64(data[iNdEx-3]) << 40 + m.Fixed64 |= uint64(data[iNdEx-2]) << 48 + m.Fixed64 |= uint64(data[iNdEx-1]) << 56 + case 8: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Fixed32", wireType) + } + m.Fixed32 = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + m.Fixed32 = uint32(data[iNdEx-4]) + m.Fixed32 |= uint32(data[iNdEx-3]) << 8 + m.Fixed32 |= uint32(data[iNdEx-2]) << 16 + m.Fixed32 |= uint32(data[iNdEx-1]) << 24 + case 9: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32", wireType) + } + m.Sfixed32 = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + m.Sfixed32 = int32(data[iNdEx-4]) + m.Sfixed32 |= int32(data[iNdEx-3]) << 8 + m.Sfixed32 |= int32(data[iNdEx-2]) << 16 + m.Sfixed32 |= int32(data[iNdEx-1]) << 24 + hasFields[0] |= uint64(0x00000008) + case 10: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64", wireType) + } + m.Sfixed64 = 0 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + m.Sfixed64 = int64(data[iNdEx-8]) + m.Sfixed64 |= int64(data[iNdEx-7]) << 8 + m.Sfixed64 |= int64(data[iNdEx-6]) << 16 + m.Sfixed64 |= int64(data[iNdEx-5]) << 24 + m.Sfixed64 |= int64(data[iNdEx-4]) << 32 + m.Sfixed64 |= int64(data[iNdEx-3]) << 40 + m.Sfixed64 |= int64(data[iNdEx-2]) << 48 + m.Sfixed64 |= int64(data[iNdEx-1]) << 56 + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Bool", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnmarshalmerge + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Bool = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipUnmarshalmerge(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthUnmarshalmerge + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + if hasFields[0]&uint64(0x00000001) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Int64") + } + if hasFields[0]&uint64(0x00000002) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Sint32") + } + if hasFields[0]&uint64(0x00000004) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Uint32") + } + if hasFields[0]&uint64(0x00000008) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Sfixed32") + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipUnmarshalmerge(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowUnmarshalmerge + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowUnmarshalmerge + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowUnmarshalmerge + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthUnmarshalmerge + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowUnmarshalmerge + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipUnmarshalmerge(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthUnmarshalmerge = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowUnmarshalmerge = fmt.Errorf("proto: integer overflow") +) + +func (m *BigUnsafe) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnmarshalmergeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BigUnsafe: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BigUnsafe: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Sub", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnmarshalmergeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthUnmarshalmergeUnsafe + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Sub == nil { + m.Sub = &Sub{} + } + if err := m.Sub.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnmarshalmergeUnsafe + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Number = &v + default: + iNdEx = preIndex + skippy, err := skipUnmarshalmergeUnsafe(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthUnmarshalmergeUnsafe + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipUnmarshalmergeUnsafe(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowUnmarshalmergeUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowUnmarshalmergeUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowUnmarshalmergeUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthUnmarshalmergeUnsafe + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowUnmarshalmergeUnsafe + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipUnmarshalmergeUnsafe(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthUnmarshalmergeUnsafe = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowUnmarshalmergeUnsafe = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unmarshalmerge/unmarshalmerge.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unmarshalmerge/unmarshalmerge.proto new file mode 100644 index 0000000000000000000000000000000000000000..b2ca42c1226942e3873b4d8c60ee72dceb66e18d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unmarshalmerge/unmarshalmerge.proto @@ -0,0 +1,73 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package unmarshalmerge; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.goproto_stringer_all) = false; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; +option (gogoproto.benchgen_all) = true; + +message Big { + option (gogoproto.unmarshaler) = true; + optional Sub Sub = 1; + optional int64 Number = 2; +} + +message BigUnsafe { + option (gogoproto.unsafe_unmarshaler) = true; + optional Sub Sub = 1; + optional int64 Number = 2; +} + +message Sub { + option (gogoproto.unmarshaler) = true; + optional int64 SubNumber = 1; +} + +message IntMerge { + option (gogoproto.unmarshaler) = true; + required int64 Int64 = 1 [(gogoproto.nullable) = false]; + optional int32 Int32 = 2 [(gogoproto.nullable) = false]; + required sint32 Sint32 = 3 [(gogoproto.nullable) = false]; + optional sint64 Sint64 = 4 [(gogoproto.nullable) = false]; + optional uint64 Uint64 = 5 [(gogoproto.nullable) = false]; + required uint32 Uint32 = 6 [(gogoproto.nullable) = false]; + optional fixed64 Fixed64 = 7 [(gogoproto.nullable) = false]; + optional fixed32 Fixed32 = 8 [(gogoproto.nullable) = false]; + required sfixed32 Sfixed32 = 9 [(gogoproto.nullable) = false]; + optional sfixed64 Sfixed64 = 10 [(gogoproto.nullable) = false]; + optional bool Bool = 11 [(gogoproto.nullable) = false]; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unmarshalmerge/unmarshalmerge_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unmarshalmerge/unmarshalmerge_test.go new file mode 100644 index 0000000000000000000000000000000000000000..287d25f9defee2c8244c2bb4ae7c65e2350e1e6d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unmarshalmerge/unmarshalmerge_test.go @@ -0,0 +1,71 @@ +package unmarshalmerge + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + math_rand "math/rand" + "testing" + "time" +) + +func TestUnmarshalMerge(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedBig(popr, true) + if p.GetSub() == nil { + p.Sub = &Sub{SubNumber: proto.Int64(12345)} + } + data, err := proto.Marshal(p) + if err != nil { + t.Fatal(err) + } + s := &Sub{} + b := &Big{ + Sub: s, + } + err = proto.UnmarshalMerge(data, b) + if err != nil { + t.Fatal(err) + } + if s.GetSubNumber() != p.GetSub().GetSubNumber() { + t.Fatalf("should have unmarshaled subnumber into sub") + } +} + +func TestUnsafeUnmarshalMerge(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedBigUnsafe(popr, true) + if p.GetSub() == nil { + p.Sub = &Sub{SubNumber: proto.Int64(12345)} + } + data, err := proto.Marshal(p) + if err != nil { + t.Fatal(err) + } + s := &Sub{} + b := &BigUnsafe{ + Sub: s, + } + err = proto.UnmarshalMerge(data, b) + if err != nil { + t.Fatal(err) + } + + if s.GetSubNumber() != p.GetSub().GetSubNumber() { + t.Fatalf("should have unmarshaled subnumber into sub") + } +} + +func TestInt64Merge(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedIntMerge(popr, true) + p2 := NewPopulatedIntMerge(popr, true) + data, err := proto.Marshal(p2) + if err != nil { + t.Fatal(err) + } + if err := proto.UnmarshalMerge(data, p); err != nil { + t.Fatal(err) + } + if !p.Equal(p2) { + t.Fatalf("exptected %#v but got %#v", p2, p) + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unmarshalmerge/unmarshalmergepb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unmarshalmerge/unmarshalmergepb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..542e66b135563d1ab7d94587c6091f3dd6db8542 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unmarshalmerge/unmarshalmergepb_test.go @@ -0,0 +1,701 @@ +// Code generated by protoc-gen-gogo. +// source: unmarshalmerge.proto +// DO NOT EDIT! + +/* +Package unmarshalmerge is a generated protocol buffer package. + +It is generated from these files: + unmarshalmerge.proto + +It has these top-level messages: + Big + BigUnsafe + Sub + IntMerge +*/ +package unmarshalmerge + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestBigProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedBig(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Big{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkBigProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Big, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedBig(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkBigProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedBig(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Big{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestBigUnsafeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedBigUnsafe(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &BigUnsafe{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkBigUnsafeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*BigUnsafe, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedBigUnsafe(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkBigUnsafeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedBigUnsafe(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &BigUnsafe{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestSubProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSub(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Sub{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkSubProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*Sub, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedSub(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkSubProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedSub(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &Sub{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestIntMergeProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedIntMerge(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &IntMerge{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func BenchmarkIntMergeProtoMarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + pops := make([]*IntMerge, 10000) + for i := 0; i < 10000; i++ { + pops[i] = NewPopulatedIntMerge(popr, false) + } + b.ResetTimer() + for i := 0; i < b.N; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(pops[i%10000]) + if err != nil { + panic(err) + } + total += len(data) + } + b.SetBytes(int64(total / b.N)) +} + +func BenchmarkIntMergeProtoUnmarshal(b *testing.B) { + popr := math_rand.New(math_rand.NewSource(616)) + total := 0 + datas := make([][]byte, 10000) + for i := 0; i < 10000; i++ { + data, err := github_com_gogo_protobuf_proto.Marshal(NewPopulatedIntMerge(popr, false)) + if err != nil { + panic(err) + } + datas[i] = data + } + msg := &IntMerge{} + b.ResetTimer() + for i := 0; i < b.N; i++ { + total += len(datas[i%10000]) + if err := github_com_gogo_protobuf_proto.Unmarshal(datas[i%10000], msg); err != nil { + panic(err) + } + } + b.SetBytes(int64(total / b.N)) +} + +func TestBigJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedBig(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Big{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestBigUnsafeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedBigUnsafe(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &BigUnsafe{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestSubJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSub(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &Sub{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestIntMergeJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedIntMerge(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &IntMerge{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestBigProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedBig(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Big{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestBigProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedBig(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Big{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestBigUnsafeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedBigUnsafe(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &BigUnsafe{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestBigUnsafeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedBigUnsafe(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &BigUnsafe{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSub(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &Sub{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestSubProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedSub(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &Sub{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestIntMergeProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedIntMerge(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &IntMerge{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestIntMergeProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedIntMerge(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &IntMerge{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestBigVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedBig(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Big{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestBigUnsafeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedBigUnsafe(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &BigUnsafe{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestSubVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSub(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &Sub{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestIntMergeVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedIntMerge(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &IntMerge{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestBigGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedBig(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestBigUnsafeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedBigUnsafe(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestSubGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSub(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestIntMergeGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedIntMerge(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestBigStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedBig(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestBigUnsafeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedBigUnsafe(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestSubStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedSub(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestIntMergeStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedIntMerge(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognized/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognized/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..bb731f099fa53c0547c458fc711367aaca22cdb8 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognized/Makefile @@ -0,0 +1,30 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. unrecognized.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognized/oldnew_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognized/oldnew_test.go new file mode 100644 index 0000000000000000000000000000000000000000..9632131806a7b97905bf4ee472a9ee7cb2dc6e44 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognized/oldnew_test.go @@ -0,0 +1,198 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 unrecognized + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + math_rand "math/rand" + "testing" + time "time" +) + +func TestNewOld(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + newer := NewPopulatedA(popr, true) + data1, err := proto.Marshal(newer) + if err != nil { + panic(err) + } + older := &OldA{} + if err := proto.Unmarshal(data1, older); err != nil { + panic(err) + } + data2, err := proto.Marshal(older) + if err != nil { + panic(err) + } + bluer := &A{} + if err := proto.Unmarshal(data2, bluer); err != nil { + panic(err) + } + if err := newer.VerboseEqual(bluer); err != nil { + t.Fatalf("%#v !VerboseProto %#v, since %v", newer, bluer, err) + } +} + +func TestOldNew(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + older := NewPopulatedOldA(popr, true) + data1, err := proto.Marshal(older) + if err != nil { + panic(err) + } + newer := &A{} + if err := proto.Unmarshal(data1, newer); err != nil { + panic(err) + } + data2, err := proto.Marshal(newer) + if err != nil { + panic(err) + } + bluer := &OldA{} + if err := proto.Unmarshal(data2, bluer); err != nil { + panic(err) + } + if err := older.VerboseEqual(bluer); err != nil { + t.Fatalf("%#v !VerboseProto %#v, since %v", older, bluer, err) + } +} + +func TestOldNewOldNew(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + older := NewPopulatedOldA(popr, true) + data1, err := proto.Marshal(older) + if err != nil { + panic(err) + } + newer := &A{} + if err := proto.Unmarshal(data1, newer); err != nil { + panic(err) + } + data2, err := proto.Marshal(newer) + if err != nil { + panic(err) + } + bluer := &OldA{} + if err := proto.Unmarshal(data2, bluer); err != nil { + panic(err) + } + if err := older.VerboseEqual(bluer); err != nil { + t.Fatalf("%#v !VerboseProto %#v, since %v", older, bluer, err) + } + + data3, err := proto.Marshal(bluer) + if err != nil { + panic(err) + } + purple := &A{} + if err := proto.Unmarshal(data3, purple); err != nil { + panic(err) + } + data4, err := proto.Marshal(purple) + if err != nil { + panic(err) + } + magenta := &OldA{} + if err := proto.Unmarshal(data4, magenta); err != nil { + panic(err) + } + if err := older.VerboseEqual(magenta); err != nil { + t.Fatalf("%#v !VerboseProto %#v, since %v", older, magenta, err) + } +} + +func TestOldUToU(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + older := NewPopulatedOldU(popr, true) + // need optional field to be always initialized, to check it's lost in this test + older.Field1 = proto.String(randStringUnrecognized(popr)) + data1, err := proto.Marshal(older) + if err != nil { + panic(err) + } + + newer := &U{} + if err := proto.Unmarshal(data1, newer); err != nil { + panic(err) + } + data2, err := proto.Marshal(newer) + if err != nil { + panic(err) + } + + older2 := &OldU{} + if err := proto.Unmarshal(data2, older2); err != nil { + panic(err) + } + + // check that Field1 is lost + if older2.Field1 != nil { + t.Fatalf("field must be lost, but it's not, older: %#v, older2: %#v", older, older2) + } + + // now restore Field1 and messages should be equal now + older2.Field1 = older.Field1 + if err := older.VerboseEqual(older2); err != nil { + t.Fatalf("%#v !VerboseProto %#v, since %v", older, older2, err) + } +} + +func TestOldUnoM(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + older := NewPopulatedOldUnoM(popr, true) + // need optional field to be always initialized, to check it's lost in this test + older.Field1 = proto.String(randStringUnrecognized(popr)) + data1, err := proto.Marshal(older) + if err != nil { + panic(err) + } + + newer := &UnoM{} + if err := proto.Unmarshal(data1, newer); err != nil { + panic(err) + } + data2, err := proto.Marshal(newer) + if err != nil { + panic(err) + } + + older2 := &OldUnoM{} + if err := proto.Unmarshal(data2, older2); err != nil { + panic(err) + } + + // check that Field1 is lost + if older2.Field1 != nil { + t.Fatalf("field must be lost, but it's not, older: %#v, older2: %#v", older, older2) + } + + // now restore Field1 and messages should be equal now + older2.Field1 = older.Field1 + if err := older.VerboseEqual(older2); err != nil { + t.Fatalf("%#v !VerboseProto %#v, since %v", older, older2, err) + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognized/unrecognized.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognized/unrecognized.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..1c9be1833f2f9d7e94665b9321ebd099b1674334 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognized/unrecognized.pb.go @@ -0,0 +1,5364 @@ +// Code generated by protoc-gen-gogo. +// source: unrecognized.proto +// DO NOT EDIT! + +/* + Package unrecognized is a generated protocol buffer package. + + It is generated from these files: + unrecognized.proto + + It has these top-level messages: + A + B + D + C + U + UnoM + OldA + OldB + OldC + OldU + OldUnoM +*/ +package unrecognized + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type A struct { + Field1 *int64 `protobuf:"varint,2,opt,name=Field1" json:"Field1,omitempty"` + B []*B `protobuf:"bytes,1,rep,name=B" json:"B,omitempty"` +} + +func (m *A) Reset() { *m = A{} } +func (*A) ProtoMessage() {} + +type B struct { + C *C `protobuf:"bytes,1,opt,name=C" json:"C,omitempty"` + D *D `protobuf:"bytes,2,opt,name=D" json:"D,omitempty"` + F *OldC `protobuf:"bytes,5,opt,name=F" json:"F,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *B) Reset() { *m = B{} } +func (*B) ProtoMessage() {} + +type D struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *D) Reset() { *m = D{} } +func (*D) ProtoMessage() {} + +type C struct { + Field2 *float64 `protobuf:"fixed64,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *string `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + Field4 *float64 `protobuf:"fixed64,4,opt,name=Field4" json:"Field4,omitempty"` + Field5 [][]byte `protobuf:"bytes,5,rep,name=Field5" json:"Field5,omitempty"` + Field6 *int64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 []float32 `protobuf:"fixed32,7,rep,name=Field7" json:"Field7,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *C) Reset() { *m = C{} } +func (*C) ProtoMessage() {} + +type U struct { + Field2 []float64 `protobuf:"fixed64,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 *uint32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` +} + +func (m *U) Reset() { *m = U{} } +func (*U) ProtoMessage() {} + +type UnoM struct { + Field2 []float64 `protobuf:"fixed64,2,rep,name=Field2" json:"Field2,omitempty"` + Field3 *uint32 `protobuf:"varint,3,opt,name=Field3" json:"Field3,omitempty"` +} + +func (m *UnoM) Reset() { *m = UnoM{} } +func (*UnoM) ProtoMessage() {} + +type OldA struct { + Field1 *int64 `protobuf:"varint,2,opt,name=Field1" json:"Field1,omitempty"` + B []*OldB `protobuf:"bytes,1,rep,name=B" json:"B,omitempty"` +} + +func (m *OldA) Reset() { *m = OldA{} } +func (*OldA) ProtoMessage() {} + +type OldB struct { + C *OldC `protobuf:"bytes,1,opt,name=C" json:"C,omitempty"` + F *OldC `protobuf:"bytes,5,opt,name=F" json:"F,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OldB) Reset() { *m = OldB{} } +func (*OldB) ProtoMessage() {} + +type OldC struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *float64 `protobuf:"fixed64,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 *string `protobuf:"bytes,3,opt,name=Field3" json:"Field3,omitempty"` + Field6 *int64 `protobuf:"varint,6,opt,name=Field6" json:"Field6,omitempty"` + Field7 []float32 `protobuf:"fixed32,7,rep,name=Field7" json:"Field7,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OldC) Reset() { *m = OldC{} } +func (*OldC) ProtoMessage() {} + +type OldU struct { + Field1 *string `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 []float64 `protobuf:"fixed64,2,rep,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OldU) Reset() { *m = OldU{} } +func (*OldU) ProtoMessage() {} + +type OldUnoM struct { + Field1 *string `protobuf:"bytes,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 []float64 `protobuf:"fixed64,2,rep,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OldUnoM) Reset() { *m = OldUnoM{} } +func (*OldUnoM) ProtoMessage() {} + +func (this *A) Description() (desc *google_protobuf.FileDescriptorSet) { + return UnrecognizedDescription() +} +func (this *B) Description() (desc *google_protobuf.FileDescriptorSet) { + return UnrecognizedDescription() +} +func (this *D) Description() (desc *google_protobuf.FileDescriptorSet) { + return UnrecognizedDescription() +} +func (this *C) Description() (desc *google_protobuf.FileDescriptorSet) { + return UnrecognizedDescription() +} +func (this *U) Description() (desc *google_protobuf.FileDescriptorSet) { + return UnrecognizedDescription() +} +func (this *UnoM) Description() (desc *google_protobuf.FileDescriptorSet) { + return UnrecognizedDescription() +} +func (this *OldA) Description() (desc *google_protobuf.FileDescriptorSet) { + return UnrecognizedDescription() +} +func (this *OldB) Description() (desc *google_protobuf.FileDescriptorSet) { + return UnrecognizedDescription() +} +func (this *OldC) Description() (desc *google_protobuf.FileDescriptorSet) { + return UnrecognizedDescription() +} +func (this *OldU) Description() (desc *google_protobuf.FileDescriptorSet) { + return UnrecognizedDescription() +} +func (this *OldUnoM) Description() (desc *google_protobuf.FileDescriptorSet) { + return UnrecognizedDescription() +} +func UnrecognizedDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("unrecognized.proto"), + Package: func(v string) *string { return &v }("unrecognized"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("A"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".unrecognized.B"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("B"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".unrecognized.C"), + }, {Name: func(v string) *string { return &v }("D"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".unrecognized.D"), + }, {Name: func(v string) *string { return &v }("F"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".unrecognized.OldC"), + }}, + }, {Name: func(v string) *string { return &v }("D"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + }, {Name: func(v string) *string { return &v }("C"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field4"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field5"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }}, + }, {Name: func(v string) *string { return &v }("U"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("UnoM"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(13), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64017: proto.NewExtension([]byte{0x88, 0xa1, 0x1f, 0x0}), 64018: proto.NewExtension([]byte{0x90, 0xa1, 0x1f, 0x0}), 64020: proto.NewExtension([]byte{0xa0, 0xa1, 0x1f, 0x0}), 64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("OldA"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("B"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".unrecognized.OldB"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64026: proto.NewExtension([]byte{0xd0, 0xa1, 0x1f, 0x0})}}, + }, {Name: func(v string) *string { return &v }("OldB"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("C"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".unrecognized.OldC"), + }, {Name: func(v string) *string { return &v }("F"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".unrecognized.OldC"), + }}, + }, {Name: func(v string) *string { return &v }("OldC"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field6"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field7"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(2), + }}, + }, {Name: func(v string) *string { return &v }("OldU"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }, {Name: func(v string) *string { return &v }("OldUnoM"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64017: proto.NewExtension([]byte{0x88, 0xa1, 0x1f, 0x0}), 64018: proto.NewExtension([]byte{0x90, 0xa1, 0x1f, 0x0}), 64020: proto.NewExtension([]byte{0xa0, 0xa1, 0x1f, 0x0})}}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1}), 63017: proto.NewExtension([]byte{0xc8, 0xe2, 0x1e, 0x1}), 63018: proto.NewExtension([]byte{0xd0, 0xe2, 0x1e, 0x1}), 63020: proto.NewExtension([]byte{0xe0, 0xe2, 0x1e, 0x1})}}, + }}, + } +} +func (this *A) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*A) + if !ok { + return fmt.Errorf("that is not of type *A") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *A but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Abut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.B) != len(that1.B) { + return fmt.Errorf("B this(%v) Not Equal that(%v)", len(this.B), len(that1.B)) + } + for i := range this.B { + if !this.B[i].Equal(that1.B[i]) { + return fmt.Errorf("B this[%v](%v) Not Equal that[%v](%v)", i, this.B[i], i, that1.B[i]) + } + } + return nil +} +func (this *A) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*A) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if len(this.B) != len(that1.B) { + return false + } + for i := range this.B { + if !this.B[i].Equal(that1.B[i]) { + return false + } + } + return true +} +func (this *B) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*B) + if !ok { + return fmt.Errorf("that is not of type *B") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *B but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Bbut is not nil && this == nil") + } + if !this.C.Equal(that1.C) { + return fmt.Errorf("C this(%v) Not Equal that(%v)", this.C, that1.C) + } + if !this.D.Equal(that1.D) { + return fmt.Errorf("D this(%v) Not Equal that(%v)", this.D, that1.D) + } + if !this.F.Equal(that1.F) { + return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *B) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*B) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.C.Equal(that1.C) { + return false + } + if !this.D.Equal(that1.D) { + return false + } + if !this.F.Equal(that1.F) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *D) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*D) + if !ok { + return fmt.Errorf("that is not of type *D") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *D but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Dbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *D) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*D) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *C) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*C) + if !ok { + return fmt.Errorf("that is not of type *C") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *C but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Cbut is not nil && this == nil") + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", *this.Field4, *that1.Field4) + } + } else if this.Field4 != nil { + return fmt.Errorf("this.Field4 == nil && that.Field4 != nil") + } else if that1.Field4 != nil { + return fmt.Errorf("Field4 this(%v) Not Equal that(%v)", this.Field4, that1.Field4) + } + if len(this.Field5) != len(that1.Field5) { + return fmt.Errorf("Field5 this(%v) Not Equal that(%v)", len(this.Field5), len(that1.Field5)) + } + for i := range this.Field5 { + if !bytes.Equal(this.Field5[i], that1.Field5[i]) { + return fmt.Errorf("Field5 this[%v](%v) Not Equal that[%v](%v)", i, this.Field5[i], i, that1.Field5[i]) + } + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *C) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*C) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field4 != nil && that1.Field4 != nil { + if *this.Field4 != *that1.Field4 { + return false + } + } else if this.Field4 != nil { + return false + } else if that1.Field4 != nil { + return false + } + if len(this.Field5) != len(that1.Field5) { + return false + } + for i := range this.Field5 { + if !bytes.Equal(this.Field5[i], that1.Field5[i]) { + return false + } + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *U) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*U) + if !ok { + return fmt.Errorf("that is not of type *U") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *U but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Ubut is not nil && this == nil") + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *U) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*U) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + return true +} +func (this *UnoM) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*UnoM) + if !ok { + return fmt.Errorf("that is not of type *UnoM") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *UnoM but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *UnoMbut is not nil && this == nil") + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + return nil +} +func (this *UnoM) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*UnoM) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + return true +} +func (this *OldA) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OldA) + if !ok { + return fmt.Errorf("that is not of type *OldA") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OldA but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OldAbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.B) != len(that1.B) { + return fmt.Errorf("B this(%v) Not Equal that(%v)", len(this.B), len(that1.B)) + } + for i := range this.B { + if !this.B[i].Equal(that1.B[i]) { + return fmt.Errorf("B this[%v](%v) Not Equal that[%v](%v)", i, this.B[i], i, that1.B[i]) + } + } + return nil +} +func (this *OldA) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OldA) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if len(this.B) != len(that1.B) { + return false + } + for i := range this.B { + if !this.B[i].Equal(that1.B[i]) { + return false + } + } + return true +} +func (this *OldB) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OldB) + if !ok { + return fmt.Errorf("that is not of type *OldB") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OldB but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OldBbut is not nil && this == nil") + } + if !this.C.Equal(that1.C) { + return fmt.Errorf("C this(%v) Not Equal that(%v)", this.C, that1.C) + } + if !this.F.Equal(that1.F) { + return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OldB) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OldB) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if !this.C.Equal(that1.C) { + return false + } + if !this.F.Equal(that1.F) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OldC) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OldC) + if !ok { + return fmt.Errorf("that is not of type *OldC") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OldC but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OldCbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", *this.Field3, *that1.Field3) + } + } else if this.Field3 != nil { + return fmt.Errorf("this.Field3 == nil && that.Field3 != nil") + } else if that1.Field3 != nil { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", this.Field3, that1.Field3) + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", *this.Field6, *that1.Field6) + } + } else if this.Field6 != nil { + return fmt.Errorf("this.Field6 == nil && that.Field6 != nil") + } else if that1.Field6 != nil { + return fmt.Errorf("Field6 this(%v) Not Equal that(%v)", this.Field6, that1.Field6) + } + if len(this.Field7) != len(that1.Field7) { + return fmt.Errorf("Field7 this(%v) Not Equal that(%v)", len(this.Field7), len(that1.Field7)) + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return fmt.Errorf("Field7 this[%v](%v) Not Equal that[%v](%v)", i, this.Field7[i], i, that1.Field7[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OldC) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OldC) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if this.Field3 != nil && that1.Field3 != nil { + if *this.Field3 != *that1.Field3 { + return false + } + } else if this.Field3 != nil { + return false + } else if that1.Field3 != nil { + return false + } + if this.Field6 != nil && that1.Field6 != nil { + if *this.Field6 != *that1.Field6 { + return false + } + } else if this.Field6 != nil { + return false + } else if that1.Field6 != nil { + return false + } + if len(this.Field7) != len(that1.Field7) { + return false + } + for i := range this.Field7 { + if this.Field7[i] != that1.Field7[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OldU) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OldU) + if !ok { + return fmt.Errorf("that is not of type *OldU") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OldU but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OldUbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OldU) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OldU) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OldUnoM) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OldUnoM) + if !ok { + return fmt.Errorf("that is not of type *OldUnoM") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OldUnoM but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OldUnoMbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OldUnoM) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OldUnoM) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *A) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&unrecognized.A{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringUnrecognized(this.Field1, "int64")+",\n") + } + if this.B != nil { + s = append(s, "B: "+fmt.Sprintf("%#v", this.B)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *B) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&unrecognized.B{") + if this.C != nil { + s = append(s, "C: "+fmt.Sprintf("%#v", this.C)+",\n") + } + if this.D != nil { + s = append(s, "D: "+fmt.Sprintf("%#v", this.D)+",\n") + } + if this.F != nil { + s = append(s, "F: "+fmt.Sprintf("%#v", this.F)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *D) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&unrecognized.D{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringUnrecognized(this.Field1, "int64")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *C) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 10) + s = append(s, "&unrecognized.C{") + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringUnrecognized(this.Field2, "float64")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringUnrecognized(this.Field3, "string")+",\n") + } + if this.Field4 != nil { + s = append(s, "Field4: "+valueToGoStringUnrecognized(this.Field4, "float64")+",\n") + } + if this.Field5 != nil { + s = append(s, "Field5: "+fmt.Sprintf("%#v", this.Field5)+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringUnrecognized(this.Field6, "int64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *U) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&unrecognized.U{") + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringUnrecognized(this.Field3, "uint32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *UnoM) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&unrecognized.UnoM{") + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringUnrecognized(this.Field3, "uint32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OldA) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&unrecognized.OldA{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringUnrecognized(this.Field1, "int64")+",\n") + } + if this.B != nil { + s = append(s, "B: "+fmt.Sprintf("%#v", this.B)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OldB) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&unrecognized.OldB{") + if this.C != nil { + s = append(s, "C: "+fmt.Sprintf("%#v", this.C)+",\n") + } + if this.F != nil { + s = append(s, "F: "+fmt.Sprintf("%#v", this.F)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OldC) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 9) + s = append(s, "&unrecognized.OldC{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringUnrecognized(this.Field1, "int64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringUnrecognized(this.Field2, "float64")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+valueToGoStringUnrecognized(this.Field3, "string")+",\n") + } + if this.Field6 != nil { + s = append(s, "Field6: "+valueToGoStringUnrecognized(this.Field6, "int64")+",\n") + } + if this.Field7 != nil { + s = append(s, "Field7: "+fmt.Sprintf("%#v", this.Field7)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OldU) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&unrecognized.OldU{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringUnrecognized(this.Field1, "string")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OldUnoM) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&unrecognized.OldUnoM{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringUnrecognized(this.Field1, "string")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringUnrecognized(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringUnrecognized(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *A) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *A) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.B) > 0 { + for _, msg := range m.B { + data[i] = 0xa + i++ + i = encodeVarintUnrecognized(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.Field1 != nil { + data[i] = 0x10 + i++ + i = encodeVarintUnrecognized(data, i, uint64(*m.Field1)) + } + return i, nil +} + +func (m *B) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *B) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.C != nil { + data[i] = 0xa + i++ + i = encodeVarintUnrecognized(data, i, uint64(m.C.Size())) + n1, err := m.C.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n1 + } + if m.D != nil { + data[i] = 0x12 + i++ + i = encodeVarintUnrecognized(data, i, uint64(m.D.Size())) + n2, err := m.D.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + } + if m.F != nil { + data[i] = 0x2a + i++ + i = encodeVarintUnrecognized(data, i, uint64(m.F.Size())) + n3, err := m.F.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n3 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *D) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *D) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintUnrecognized(data, i, uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *C) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *C) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field2 != nil { + data[i] = 0x11 + i++ + i = encodeFixed64Unrecognized(data, i, uint64(math.Float64bits(*m.Field2))) + } + if m.Field3 != nil { + data[i] = 0x1a + i++ + i = encodeVarintUnrecognized(data, i, uint64(len(*m.Field3))) + i += copy(data[i:], *m.Field3) + } + if m.Field4 != nil { + data[i] = 0x21 + i++ + i = encodeFixed64Unrecognized(data, i, uint64(math.Float64bits(*m.Field4))) + } + if len(m.Field5) > 0 { + for _, b := range m.Field5 { + data[i] = 0x2a + i++ + i = encodeVarintUnrecognized(data, i, uint64(len(b))) + i += copy(data[i:], b) + } + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintUnrecognized(data, i, uint64(*m.Field6)) + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x3d + i++ + f4 := math.Float32bits(num) + data[i] = uint8(f4) + i++ + data[i] = uint8(f4 >> 8) + i++ + data[i] = uint8(f4 >> 16) + i++ + data[i] = uint8(f4 >> 24) + i++ + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *U) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *U) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x11 + i++ + f5 := math.Float64bits(num) + data[i] = uint8(f5) + i++ + data[i] = uint8(f5 >> 8) + i++ + data[i] = uint8(f5 >> 16) + i++ + data[i] = uint8(f5 >> 24) + i++ + data[i] = uint8(f5 >> 32) + i++ + data[i] = uint8(f5 >> 40) + i++ + data[i] = uint8(f5 >> 48) + i++ + data[i] = uint8(f5 >> 56) + i++ + } + } + if m.Field3 != nil { + data[i] = 0x18 + i++ + i = encodeVarintUnrecognized(data, i, uint64(*m.Field3)) + } + return i, nil +} + +func (m *OldA) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *OldA) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.B) > 0 { + for _, msg := range m.B { + data[i] = 0xa + i++ + i = encodeVarintUnrecognized(data, i, uint64(msg.Size())) + n, err := msg.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.Field1 != nil { + data[i] = 0x10 + i++ + i = encodeVarintUnrecognized(data, i, uint64(*m.Field1)) + } + return i, nil +} + +func (m *OldB) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *OldB) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.C != nil { + data[i] = 0xa + i++ + i = encodeVarintUnrecognized(data, i, uint64(m.C.Size())) + n6, err := m.C.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n6 + } + if m.F != nil { + data[i] = 0x2a + i++ + i = encodeVarintUnrecognized(data, i, uint64(m.F.Size())) + n7, err := m.F.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n7 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *OldC) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *OldC) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintUnrecognized(data, i, uint64(*m.Field1)) + } + if m.Field2 != nil { + data[i] = 0x11 + i++ + i = encodeFixed64Unrecognized(data, i, uint64(math.Float64bits(*m.Field2))) + } + if m.Field3 != nil { + data[i] = 0x1a + i++ + i = encodeVarintUnrecognized(data, i, uint64(len(*m.Field3))) + i += copy(data[i:], *m.Field3) + } + if m.Field6 != nil { + data[i] = 0x30 + i++ + i = encodeVarintUnrecognized(data, i, uint64(*m.Field6)) + } + if len(m.Field7) > 0 { + for _, num := range m.Field7 { + data[i] = 0x3d + i++ + f8 := math.Float32bits(num) + data[i] = uint8(f8) + i++ + data[i] = uint8(f8 >> 8) + i++ + data[i] = uint8(f8 >> 16) + i++ + data[i] = uint8(f8 >> 24) + i++ + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *OldU) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *OldU) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0xa + i++ + i = encodeVarintUnrecognized(data, i, uint64(len(*m.Field1))) + i += copy(data[i:], *m.Field1) + } + if len(m.Field2) > 0 { + for _, num := range m.Field2 { + data[i] = 0x11 + i++ + f9 := math.Float64bits(num) + data[i] = uint8(f9) + i++ + data[i] = uint8(f9 >> 8) + i++ + data[i] = uint8(f9 >> 16) + i++ + data[i] = uint8(f9 >> 24) + i++ + data[i] = uint8(f9 >> 32) + i++ + data[i] = uint8(f9 >> 40) + i++ + data[i] = uint8(f9 >> 48) + i++ + data[i] = uint8(f9 >> 56) + i++ + } + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Unrecognized(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Unrecognized(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintUnrecognized(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedA(r randyUnrecognized, easy bool) *A { + this := &A{} + if r.Intn(10) != 0 { + v1 := r.Intn(10) + this.B = make([]*B, v1) + for i := 0; i < v1; i++ { + this.B[i] = NewPopulatedB(r, easy) + } + } + if r.Intn(10) != 0 { + v2 := int64(r.Int63()) + if r.Intn(2) == 0 { + v2 *= -1 + } + this.Field1 = &v2 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedB(r randyUnrecognized, easy bool) *B { + this := &B{} + if r.Intn(10) != 0 { + this.C = NewPopulatedC(r, easy) + } + if r.Intn(10) != 0 { + this.D = NewPopulatedD(r, easy) + } + if r.Intn(10) != 0 { + this.F = NewPopulatedOldC(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedUnrecognized(r, 6) + } + return this +} + +func NewPopulatedD(r randyUnrecognized, easy bool) *D { + this := &D{} + if r.Intn(10) != 0 { + v3 := int64(r.Int63()) + if r.Intn(2) == 0 { + v3 *= -1 + } + this.Field1 = &v3 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedUnrecognized(r, 2) + } + return this +} + +func NewPopulatedC(r randyUnrecognized, easy bool) *C { + this := &C{} + if r.Intn(10) != 0 { + v4 := float64(r.Float64()) + if r.Intn(2) == 0 { + v4 *= -1 + } + this.Field2 = &v4 + } + if r.Intn(10) != 0 { + v5 := randStringUnrecognized(r) + this.Field3 = &v5 + } + if r.Intn(10) != 0 { + v6 := float64(r.Float64()) + if r.Intn(2) == 0 { + v6 *= -1 + } + this.Field4 = &v6 + } + if r.Intn(10) != 0 { + v7 := r.Intn(100) + this.Field5 = make([][]byte, v7) + for i := 0; i < v7; i++ { + v8 := r.Intn(100) + this.Field5[i] = make([]byte, v8) + for j := 0; j < v8; j++ { + this.Field5[i][j] = byte(r.Intn(256)) + } + } + } + if r.Intn(10) != 0 { + v9 := int64(r.Int63()) + if r.Intn(2) == 0 { + v9 *= -1 + } + this.Field6 = &v9 + } + if r.Intn(10) != 0 { + v10 := r.Intn(100) + this.Field7 = make([]float32, v10) + for i := 0; i < v10; i++ { + this.Field7[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedUnrecognized(r, 8) + } + return this +} + +func NewPopulatedU(r randyUnrecognized, easy bool) *U { + this := &U{} + if r.Intn(10) != 0 { + v11 := r.Intn(100) + this.Field2 = make([]float64, v11) + for i := 0; i < v11; i++ { + this.Field2[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v12 := uint32(r.Uint32()) + this.Field3 = &v12 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedUnoM(r randyUnrecognized, easy bool) *UnoM { + this := &UnoM{} + if r.Intn(10) != 0 { + v13 := r.Intn(100) + this.Field2 = make([]float64, v13) + for i := 0; i < v13; i++ { + this.Field2[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + v14 := uint32(r.Uint32()) + this.Field3 = &v14 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedOldA(r randyUnrecognized, easy bool) *OldA { + this := &OldA{} + if r.Intn(10) != 0 { + v15 := r.Intn(10) + this.B = make([]*OldB, v15) + for i := 0; i < v15; i++ { + this.B[i] = NewPopulatedOldB(r, easy) + } + } + if r.Intn(10) != 0 { + v16 := int64(r.Int63()) + if r.Intn(2) == 0 { + v16 *= -1 + } + this.Field1 = &v16 + } + if !easy && r.Intn(10) != 0 { + } + return this +} + +func NewPopulatedOldB(r randyUnrecognized, easy bool) *OldB { + this := &OldB{} + if r.Intn(10) != 0 { + this.C = NewPopulatedOldC(r, easy) + } + if r.Intn(10) != 0 { + this.F = NewPopulatedOldC(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedUnrecognized(r, 6) + } + return this +} + +func NewPopulatedOldC(r randyUnrecognized, easy bool) *OldC { + this := &OldC{} + if r.Intn(10) != 0 { + v17 := int64(r.Int63()) + if r.Intn(2) == 0 { + v17 *= -1 + } + this.Field1 = &v17 + } + if r.Intn(10) != 0 { + v18 := float64(r.Float64()) + if r.Intn(2) == 0 { + v18 *= -1 + } + this.Field2 = &v18 + } + if r.Intn(10) != 0 { + v19 := randStringUnrecognized(r) + this.Field3 = &v19 + } + if r.Intn(10) != 0 { + v20 := int64(r.Int63()) + if r.Intn(2) == 0 { + v20 *= -1 + } + this.Field6 = &v20 + } + if r.Intn(10) != 0 { + v21 := r.Intn(100) + this.Field7 = make([]float32, v21) + for i := 0; i < v21; i++ { + this.Field7[i] = float32(r.Float32()) + if r.Intn(2) == 0 { + this.Field7[i] *= -1 + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedUnrecognized(r, 8) + } + return this +} + +func NewPopulatedOldU(r randyUnrecognized, easy bool) *OldU { + this := &OldU{} + if r.Intn(10) != 0 { + v22 := randStringUnrecognized(r) + this.Field1 = &v22 + } + if r.Intn(10) != 0 { + v23 := r.Intn(100) + this.Field2 = make([]float64, v23) + for i := 0; i < v23; i++ { + this.Field2[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedUnrecognized(r, 3) + } + return this +} + +func NewPopulatedOldUnoM(r randyUnrecognized, easy bool) *OldUnoM { + this := &OldUnoM{} + if r.Intn(10) != 0 { + v24 := randStringUnrecognized(r) + this.Field1 = &v24 + } + if r.Intn(10) != 0 { + v25 := r.Intn(100) + this.Field2 = make([]float64, v25) + for i := 0; i < v25; i++ { + this.Field2[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedUnrecognized(r, 3) + } + return this +} + +type randyUnrecognized interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneUnrecognized(r randyUnrecognized) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringUnrecognized(r randyUnrecognized) string { + v26 := r.Intn(100) + tmps := make([]rune, v26) + for i := 0; i < v26; i++ { + tmps[i] = randUTF8RuneUnrecognized(r) + } + return string(tmps) +} +func randUnrecognizedUnrecognized(r randyUnrecognized, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldUnrecognized(data, r, fieldNumber, wire) + } + return data +} +func randFieldUnrecognized(data []byte, r randyUnrecognized, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateUnrecognized(data, uint64(key)) + v27 := r.Int63() + if r.Intn(2) == 0 { + v27 *= -1 + } + data = encodeVarintPopulateUnrecognized(data, uint64(v27)) + case 1: + data = encodeVarintPopulateUnrecognized(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateUnrecognized(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateUnrecognized(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateUnrecognized(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateUnrecognized(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *A) Size() (n int) { + var l int + _ = l + if len(m.B) > 0 { + for _, e := range m.B { + l = e.Size() + n += 1 + l + sovUnrecognized(uint64(l)) + } + } + if m.Field1 != nil { + n += 1 + sovUnrecognized(uint64(*m.Field1)) + } + return n +} + +func (m *B) Size() (n int) { + var l int + _ = l + if m.C != nil { + l = m.C.Size() + n += 1 + l + sovUnrecognized(uint64(l)) + } + if m.D != nil { + l = m.D.Size() + n += 1 + l + sovUnrecognized(uint64(l)) + } + if m.F != nil { + l = m.F.Size() + n += 1 + l + sovUnrecognized(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *D) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovUnrecognized(uint64(*m.Field1)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *C) Size() (n int) { + var l int + _ = l + if m.Field2 != nil { + n += 9 + } + if m.Field3 != nil { + l = len(*m.Field3) + n += 1 + l + sovUnrecognized(uint64(l)) + } + if m.Field4 != nil { + n += 9 + } + if len(m.Field5) > 0 { + for _, b := range m.Field5 { + l = len(b) + n += 1 + l + sovUnrecognized(uint64(l)) + } + } + if m.Field6 != nil { + n += 1 + sovUnrecognized(uint64(*m.Field6)) + } + if len(m.Field7) > 0 { + n += 5 * len(m.Field7) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *U) Size() (n int) { + var l int + _ = l + if len(m.Field2) > 0 { + n += 9 * len(m.Field2) + } + if m.Field3 != nil { + n += 1 + sovUnrecognized(uint64(*m.Field3)) + } + return n +} + +func (m *OldA) Size() (n int) { + var l int + _ = l + if len(m.B) > 0 { + for _, e := range m.B { + l = e.Size() + n += 1 + l + sovUnrecognized(uint64(l)) + } + } + if m.Field1 != nil { + n += 1 + sovUnrecognized(uint64(*m.Field1)) + } + return n +} + +func (m *OldB) Size() (n int) { + var l int + _ = l + if m.C != nil { + l = m.C.Size() + n += 1 + l + sovUnrecognized(uint64(l)) + } + if m.F != nil { + l = m.F.Size() + n += 1 + l + sovUnrecognized(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *OldC) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovUnrecognized(uint64(*m.Field1)) + } + if m.Field2 != nil { + n += 9 + } + if m.Field3 != nil { + l = len(*m.Field3) + n += 1 + l + sovUnrecognized(uint64(l)) + } + if m.Field6 != nil { + n += 1 + sovUnrecognized(uint64(*m.Field6)) + } + if len(m.Field7) > 0 { + n += 5 * len(m.Field7) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *OldU) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + l = len(*m.Field1) + n += 1 + l + sovUnrecognized(uint64(l)) + } + if len(m.Field2) > 0 { + n += 9 * len(m.Field2) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovUnrecognized(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozUnrecognized(x uint64) (n int) { + return sovUnrecognized(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *A) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&A{`, + `B:` + strings.Replace(fmt.Sprintf("%v", this.B), "B", "B", 1) + `,`, + `Field1:` + valueToStringUnrecognized(this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *B) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&B{`, + `C:` + strings.Replace(fmt.Sprintf("%v", this.C), "C", "C", 1) + `,`, + `D:` + strings.Replace(fmt.Sprintf("%v", this.D), "D", "D", 1) + `,`, + `F:` + strings.Replace(fmt.Sprintf("%v", this.F), "OldC", "OldC", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *D) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&D{`, + `Field1:` + valueToStringUnrecognized(this.Field1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *C) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&C{`, + `Field2:` + valueToStringUnrecognized(this.Field2) + `,`, + `Field3:` + valueToStringUnrecognized(this.Field3) + `,`, + `Field4:` + valueToStringUnrecognized(this.Field4) + `,`, + `Field5:` + fmt.Sprintf("%v", this.Field5) + `,`, + `Field6:` + valueToStringUnrecognized(this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *U) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&U{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + valueToStringUnrecognized(this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *UnoM) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&UnoM{`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `Field3:` + valueToStringUnrecognized(this.Field3) + `,`, + `}`, + }, "") + return s +} +func (this *OldA) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OldA{`, + `B:` + strings.Replace(fmt.Sprintf("%v", this.B), "OldB", "OldB", 1) + `,`, + `Field1:` + valueToStringUnrecognized(this.Field1) + `,`, + `}`, + }, "") + return s +} +func (this *OldB) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OldB{`, + `C:` + strings.Replace(fmt.Sprintf("%v", this.C), "OldC", "OldC", 1) + `,`, + `F:` + strings.Replace(fmt.Sprintf("%v", this.F), "OldC", "OldC", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OldC) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OldC{`, + `Field1:` + valueToStringUnrecognized(this.Field1) + `,`, + `Field2:` + valueToStringUnrecognized(this.Field2) + `,`, + `Field3:` + valueToStringUnrecognized(this.Field3) + `,`, + `Field6:` + valueToStringUnrecognized(this.Field6) + `,`, + `Field7:` + fmt.Sprintf("%v", this.Field7) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OldU) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OldU{`, + `Field1:` + valueToStringUnrecognized(this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OldUnoM) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OldUnoM{`, + `Field1:` + valueToStringUnrecognized(this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringUnrecognized(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *A) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: A: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: A: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthUnrecognized + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.B = append(m.B, &B{}) + if err := m.B[len(m.B)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipUnrecognized(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthUnrecognized + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *B) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: B: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: B: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field C", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthUnrecognized + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.C == nil { + m.C = &C{} + } + if err := m.C.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field D", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthUnrecognized + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.D == nil { + m.D = &D{} + } + if err := m.D.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field F", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthUnrecognized + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.F == nil { + m.F = &OldC{} + } + if err := m.F.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipUnrecognized(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthUnrecognized + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *D) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: D: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: D: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipUnrecognized(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthUnrecognized + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *C) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: C: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: C: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field2 = &v2 + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthUnrecognized + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field3 = &s + iNdEx = postIndex + case 4: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field4", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field4 = &v2 + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field5", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + byteLen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthUnrecognized + } + postIndex := iNdEx + byteLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Field5 = append(m.Field5, make([]byte, postIndex-iNdEx)) + copy(m.Field5[len(m.Field5)-1], data[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field7 = append(m.Field7, v2) + default: + iNdEx = preIndex + skippy, err := skipUnrecognized(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthUnrecognized + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *U) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: U: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: U: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field2 = append(m.Field2, v2) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v uint32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (uint32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field3 = &v + default: + iNdEx = preIndex + skippy, err := skipUnrecognized(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthUnrecognized + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OldA) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OldA: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OldA: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthUnrecognized + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.B = append(m.B, &OldB{}) + if err := m.B[len(m.B)-1].Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + default: + iNdEx = preIndex + skippy, err := skipUnrecognized(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthUnrecognized + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OldB) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OldB: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OldB: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field C", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthUnrecognized + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.C == nil { + m.C = &OldC{} + } + if err := m.C.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field F", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthUnrecognized + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.F == nil { + m.F = &OldC{} + } + if err := m.F.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipUnrecognized(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthUnrecognized + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OldC) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OldC: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OldC: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + case 2: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field2 = &v2 + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthUnrecognized + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field3 = &s + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field6", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field6 = &v + case 7: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Field7", wireType) + } + var v uint32 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 4 + v = uint32(data[iNdEx-4]) + v |= uint32(data[iNdEx-3]) << 8 + v |= uint32(data[iNdEx-2]) << 16 + v |= uint32(data[iNdEx-1]) << 24 + v2 := float32(math.Float32frombits(v)) + m.Field7 = append(m.Field7, v2) + default: + iNdEx = preIndex + skippy, err := skipUnrecognized(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthUnrecognized + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *OldU) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: OldU: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OldU: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthUnrecognized + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Field1 = &s + iNdEx = postIndex + case 2: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field2", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field2 = append(m.Field2, v2) + default: + iNdEx = preIndex + skippy, err := skipUnrecognized(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthUnrecognized + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipUnrecognized(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthUnrecognized + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowUnrecognized + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipUnrecognized(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthUnrecognized = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowUnrecognized = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognized/unrecognized.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognized/unrecognized.proto new file mode 100644 index 0000000000000000000000000000000000000000..626ac84a2278a4b5c126fdb22b21432dc5672290 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognized/unrecognized.proto @@ -0,0 +1,129 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package unrecognized; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; + +option (gogoproto.unmarshaler_all) = true; +option (gogoproto.marshaler_all) = true; +option (gogoproto.sizer_all) = true; + +message A { + option (gogoproto.goproto_unrecognized) = false; + optional int64 Field1 = 2; + repeated B B = 1; +} + +message B { + optional C C = 1; + optional D D = 2; + optional OldC F = 5; +} + +message D { + optional int64 Field1 = 1; +} + +message C { + optional double Field2 = 2; + optional string Field3 = 3; + optional double Field4 = 4; + repeated bytes Field5 = 5; + optional int64 Field6 = 6; + repeated float Field7 = 7; +} + +message U { + // unserializing U as OldU must leave Field1 unset + option (gogoproto.goproto_unrecognized) = false; + repeated double Field2 = 2; + optional uint32 Field3 = 3; +} + +message UnoM { + // disable marshal/unmarshal generation here + // to check that reflection based code handles missing XXX_unrecognized field coorectly + option (gogoproto.sizer) = false; + option (gogoproto.marshaler) = false; + option (gogoproto.unmarshaler) = false; + // unserializing U as OldU must leave Field1 unset + option (gogoproto.goproto_unrecognized) = false; + + repeated double Field2 = 2; + optional uint32 Field3 = 3; +} + +message OldA { + // OldA == A, so removing unrecognized should not affect anything, tests must pass + option (gogoproto.goproto_unrecognized) = false; + optional int64 Field1 = 2; + repeated OldB B = 1; +} + +message OldB { + optional OldC C = 1; + optional OldC F = 5; +} + +message OldC { + optional int64 Field1 = 1; + optional double Field2 = 2; + optional string Field3 = 3; + optional int64 Field6 = 6; + repeated float Field7 = 7; +} + +message OldU { + optional string Field1 = 1; + repeated double Field2 = 2; +} + +message OldUnoM { + // disable marshal/unmarshal generation here + // to check that reflection based code handles missing XXX_unrecognized field coorectly + option (gogoproto.sizer) = false; + option (gogoproto.marshaler) = false; + option (gogoproto.unmarshaler) = false; + + optional string Field1 = 1; + repeated double Field2 = 2; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognized/unrecognizedpb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognized/unrecognizedpb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..f7c47f6a98f628b1601598a819a99ff48ec1f459 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognized/unrecognizedpb_test.go @@ -0,0 +1,1883 @@ +// Code generated by protoc-gen-gogo. +// source: unrecognized.proto +// DO NOT EDIT! + +/* +Package unrecognized is a generated protocol buffer package. + +It is generated from these files: + unrecognized.proto + +It has these top-level messages: + A + B + D + C + U + UnoM + OldA + OldB + OldC + OldU + OldUnoM +*/ +package unrecognized + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestAProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &A{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &A{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestBProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedB(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &B{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestBMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedB(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &B{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedD(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &D{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestDMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedD(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &D{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedC(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &C{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestCMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedC(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &C{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedU(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &U{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestUMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedU(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &U{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnoMProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnoM(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnoM{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestOldAProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldA(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldA{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestOldAMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldA(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldA{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldBProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldB(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldB{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestOldBMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldB(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldB{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldCProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldC(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldC{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestOldCMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldC(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldC{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldUProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldU(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldU{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestOldUMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldU(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldU{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldUnoMProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldUnoM(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldUnoM{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &A{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestBJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedB(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &B{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestDJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedD(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &D{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestCJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedC(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &C{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedU(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &U{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestUnoMJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnoM(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &UnoM{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOldAJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldA(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldA{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOldBJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldB(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldB{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOldCJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldC(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldC{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOldUJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldU(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldU{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOldUnoMJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldUnoM(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldUnoM{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &A{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &A{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestBProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedB(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &B{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestBProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedB(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &B{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedD(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &D{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestDProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedD(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &D{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedC(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &C{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestCProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedC(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &C{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedU(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &U{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedU(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &U{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnoMProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnoM(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &UnoM{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnoMProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedUnoM(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &UnoM{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldAProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldA(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OldA{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldAProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldA(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OldA{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldBProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldB(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OldB{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldBProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldB(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OldB{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldCProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldC(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OldC{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldCProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldC(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OldC{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldUProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldU(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OldU{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldUProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldU(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OldU{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldUnoMProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldUnoM(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OldUnoM{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldUnoMProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldUnoM(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OldUnoM{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedDescription(t *testing.T) { + UnrecognizedDescription() +} +func TestAVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedA(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &A{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestBVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedB(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &B{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestDVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedD(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &D{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestCVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedC(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &C{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedU(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &U{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestUnoMVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnoM(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &UnoM{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOldAVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldA(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OldA{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOldBVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldB(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OldB{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOldCVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldC(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OldC{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOldUVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldU(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OldU{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOldUnoMVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldUnoM(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OldUnoM{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedA(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestBGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedB(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestDGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedD(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestCGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedC(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedU(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestUnoMGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnoM(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOldAGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldA(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOldBGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldB(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOldCGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldC(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOldUGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldU(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOldUnoMGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldUnoM(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestASize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestBSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedB(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestDSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedD(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestCSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedC(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestUSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedU(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestOldASize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldA(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestOldBSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldB(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestOldCSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldC(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestOldUSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldU(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestAStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedA(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestBStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedB(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestDStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedD(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestCStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedC(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedU(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestUnoMStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedUnoM(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOldAStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldA(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOldBStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldB(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOldCStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldC(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOldUStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldU(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOldUnoMStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldUnoM(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognizedgroup/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognizedgroup/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..71dee0d8da83f3136f5d1aefe1bcf1f157aeb90d --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognizedgroup/Makefile @@ -0,0 +1,30 @@ +# Extensions for Protocol Buffers to create more go like structures. +# +# Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +# http://github.com/gogo/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. +# +# 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 --proto_path=../../../../../:../../protobuf/:. --gogo_out=. unrecognizedgroup.proto) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognizedgroup/oldnew_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognizedgroup/oldnew_test.go new file mode 100644 index 0000000000000000000000000000000000000000..34f0db0636319d28c0d44ab1a4cfb1a4c3a64fe6 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognizedgroup/oldnew_test.go @@ -0,0 +1,126 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 unrecognizedgroup + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + math_rand "math/rand" + "testing" + time "time" +) + +func TestNewOld(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + newer := NewPopulatedNewNoGroup(popr, true) + data1, err := proto.Marshal(newer) + if err != nil { + panic(err) + } + older := &OldWithGroup{} + if err := proto.Unmarshal(data1, older); err != nil { + panic(err) + } + data2, err := proto.Marshal(older) + if err != nil { + panic(err) + } + bluer := &NewNoGroup{} + if err := proto.Unmarshal(data2, bluer); err != nil { + panic(err) + } + if err := newer.VerboseEqual(bluer); err != nil { + t.Fatalf("%#v !VerboseProto %#v, since %v", newer, bluer, err) + } +} + +func TestOldNew(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + older := NewPopulatedOldWithGroup(popr, true) + data1, err := proto.Marshal(older) + if err != nil { + panic(err) + } + newer := &NewNoGroup{} + if err := proto.Unmarshal(data1, newer); err != nil { + panic(err) + } + data2, err := proto.Marshal(newer) + if err != nil { + panic(err) + } + bluer := &OldWithGroup{} + if err := proto.Unmarshal(data2, bluer); err != nil { + panic(err) + } + if err := older.VerboseEqual(bluer); err != nil { + t.Fatalf("%#v !VerboseProto %#v, since %v", older, bluer, err) + } +} + +func TestOldNewOldNew(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + older := NewPopulatedOldWithGroup(popr, true) + data1, err := proto.Marshal(older) + if err != nil { + panic(err) + } + newer := &NewNoGroup{} + if err := proto.Unmarshal(data1, newer); err != nil { + panic(err) + } + data2, err := proto.Marshal(newer) + if err != nil { + panic(err) + } + bluer := &OldWithGroup{} + if err := proto.Unmarshal(data2, bluer); err != nil { + panic(err) + } + if err := older.VerboseEqual(bluer); err != nil { + t.Fatalf("%#v !VerboseProto %#v, since %v", older, bluer, err) + } + + data3, err := proto.Marshal(bluer) + if err != nil { + panic(err) + } + purple := &NewNoGroup{} + if err := proto.Unmarshal(data3, purple); err != nil { + panic(err) + } + data4, err := proto.Marshal(purple) + if err != nil { + panic(err) + } + magenta := &OldWithGroup{} + if err := proto.Unmarshal(data4, magenta); err != nil { + panic(err) + } + if err := older.VerboseEqual(magenta); err != nil { + t.Fatalf("%#v !VerboseProto %#v, since %v", older, magenta, err) + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognizedgroup/unrecognizedgroup.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognizedgroup/unrecognizedgroup.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..2fb48f47e883f98727efedbb98ef996ea95035c8 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognizedgroup/unrecognizedgroup.pb.go @@ -0,0 +1,2961 @@ +// Code generated by protoc-gen-gogo. +// source: unrecognizedgroup.proto +// DO NOT EDIT! + +/* + Package unrecognizedgroup is a generated protocol buffer package. + + It is generated from these files: + unrecognizedgroup.proto + + It has these top-level messages: + NewNoGroup + A + OldWithGroup +*/ +package unrecognizedgroup + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import google_protobuf "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +import bytes "bytes" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type NewNoGroup struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + Field3 []float64 `protobuf:"fixed64,3,rep,name=Field3" json:"Field3,omitempty"` + A *A `protobuf:"bytes,5,opt,name=A" json:"A,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NewNoGroup) Reset() { *m = NewNoGroup{} } +func (*NewNoGroup) ProtoMessage() {} + +type A struct { + AField *int64 `protobuf:"varint,1,opt,name=AField" json:"AField,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *A) Reset() { *m = A{} } +func (*A) ProtoMessage() {} + +type OldWithGroup struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + Group1 *OldWithGroup_Group1 `protobuf:"group,2,opt,name=Group1" json:"group1,omitempty"` + Field3 []float64 `protobuf:"fixed64,3,rep,name=Field3" json:"Field3,omitempty"` + Group2 *OldWithGroup_Group2 `protobuf:"group,4,opt,name=Group2" json:"group2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OldWithGroup) Reset() { *m = OldWithGroup{} } +func (*OldWithGroup) ProtoMessage() {} + +type OldWithGroup_Group1 struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 *int32 `protobuf:"varint,2,opt,name=Field2" json:"Field2,omitempty"` + Field3 []float64 `protobuf:"fixed64,3,rep,name=Field3" json:"Field3,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OldWithGroup_Group1) Reset() { *m = OldWithGroup_Group1{} } +func (*OldWithGroup_Group1) ProtoMessage() {} + +type OldWithGroup_Group2 struct { + Field1 *int64 `protobuf:"varint,1,opt,name=Field1" json:"Field1,omitempty"` + Field2 []float64 `protobuf:"fixed64,2,rep,name=Field2" json:"Field2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OldWithGroup_Group2) Reset() { *m = OldWithGroup_Group2{} } +func (*OldWithGroup_Group2) ProtoMessage() {} + +func (this *NewNoGroup) Description() (desc *google_protobuf.FileDescriptorSet) { + return UnrecognizedgroupDescription() +} +func (this *A) Description() (desc *google_protobuf.FileDescriptorSet) { + return UnrecognizedgroupDescription() +} +func (this *OldWithGroup) Description() (desc *google_protobuf.FileDescriptorSet) { + return UnrecognizedgroupDescription() +} +func (this *OldWithGroup_Group1) Description() (desc *google_protobuf.FileDescriptorSet) { + return UnrecognizedgroupDescription() +} +func (this *OldWithGroup_Group2) Description() (desc *google_protobuf.FileDescriptorSet) { + return UnrecognizedgroupDescription() +} +func UnrecognizedgroupDescription() (desc *google_protobuf.FileDescriptorSet) { + return &google_protobuf.FileDescriptorSet{File: []*google_protobuf.FileDescriptorProto{{Name: func(v string) *string { return &v }("google/protobuf/descriptor.proto"), + Package: func(v string) *string { return &v }("google.protobuf"), + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("FileDescriptorSet"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("file"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileDescriptorProto"), + }}, + }, {Name: func(v string) *string { return &v }("FileDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("package"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("dependency"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("public_dependency"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("weak_dependency"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("message_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("service"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("source_code_info"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo"), + }, {Name: func(v string) *string { return &v }("syntax"), + Number: func(v int32) *int32 { return &v }(12), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("DescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("field"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto"), + }, {Name: func(v string) *string { return &v }("nested_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto"), + }, {Name: func(v string) *string { return &v }("enum_type"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumDescriptorProto"), + }, {Name: func(v string) *string { return &v }("extension_range"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.DescriptorProto.ExtensionRange"), + }, {Name: func(v string) *string { return &v }("oneof_decl"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.OneofDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("ExtensionRange"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("start"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("end"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }}, + }}, + }, {Name: func(v string) *string { return &v }("FieldDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("label"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Label"), + }, {Name: func(v string) *string { return &v }("type"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldDescriptorProto.Type"), + }, {Name: func(v string) *string { return &v }("type_name"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("extendee"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("default_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("oneof_index"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("Type"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("TYPE_DOUBLE"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("TYPE_FLOAT"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("TYPE_INT64"), + Number: func(v int32) *int32 { return &v }(3), + }, {Name: func(v string) *string { return &v }("TYPE_UINT64"), + Number: func(v int32) *int32 { return &v }(4), + }, {Name: func(v string) *string { return &v }("TYPE_INT32"), + Number: func(v int32) *int32 { return &v }(5), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED64"), + Number: func(v int32) *int32 { return &v }(6), + }, {Name: func(v string) *string { return &v }("TYPE_FIXED32"), + Number: func(v int32) *int32 { return &v }(7), + }, {Name: func(v string) *string { return &v }("TYPE_BOOL"), + Number: func(v int32) *int32 { return &v }(8), + }, {Name: func(v string) *string { return &v }("TYPE_STRING"), + Number: func(v int32) *int32 { return &v }(9), + }, {Name: func(v string) *string { return &v }("TYPE_GROUP"), + Number: func(v int32) *int32 { return &v }(10), + }, {Name: func(v string) *string { return &v }("TYPE_MESSAGE"), + Number: func(v int32) *int32 { return &v }(11), + }, {Name: func(v string) *string { return &v }("TYPE_BYTES"), + Number: func(v int32) *int32 { return &v }(12), + }, {Name: func(v string) *string { return &v }("TYPE_UINT32"), + Number: func(v int32) *int32 { return &v }(13), + }, {Name: func(v string) *string { return &v }("TYPE_ENUM"), + Number: func(v int32) *int32 { return &v }(14), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED32"), + Number: func(v int32) *int32 { return &v }(15), + }, {Name: func(v string) *string { return &v }("TYPE_SFIXED64"), + Number: func(v int32) *int32 { return &v }(16), + }, {Name: func(v string) *string { return &v }("TYPE_SINT32"), + Number: func(v int32) *int32 { return &v }(17), + }, {Name: func(v string) *string { return &v }("TYPE_SINT64"), + Number: func(v int32) *int32 { return &v }(18), + }}, + }, {Name: func(v string) *string { return &v }("Label"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("LABEL_OPTIONAL"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("LABEL_REQUIRED"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LABEL_REPEATED"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + }, {Name: func(v string) *string { return &v }("OneofDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }, {Name: func(v string) *string { return &v }("EnumDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("value"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("number"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.EnumValueOptions"), + }}, + }, {Name: func(v string) *string { return &v }("ServiceDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("method"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodDescriptorProto"), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.ServiceOptions"), + }}, + }, {Name: func(v string) *string { return &v }("MethodDescriptorProto"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("input_type"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("output_type"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("options"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.MethodOptions"), + }, {Name: func(v string) *string { return &v }("client_streaming"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("server_streaming"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }}, + }, {Name: func(v string) *string { return &v }("FileOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("java_package"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_outer_classname"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("java_multiple_files"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generate_equals_and_hash"), + Number: func(v int32) *int32 { return &v }(20), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_string_check_utf8"), + Number: func(v int32) *int32 { return &v }(27), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("optimize_for"), + Number: func(v int32) *int32 { return &v }(9), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FileOptions.OptimizeMode"), + DefaultValue: func(v string) *string { return &v }("SPEED"), + }, {Name: func(v string) *string { return &v }("go_package"), + Number: func(v int32) *int32 { return &v }(11), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("cc_generic_services"), + Number: func(v int32) *int32 { return &v }(16), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("java_generic_services"), + Number: func(v int32) *int32 { return &v }(17), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("py_generic_services"), + Number: func(v int32) *int32 { return &v }(18), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(23), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("cc_enable_arenas"), + Number: func(v int32) *int32 { return &v }(31), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("OptimizeMode"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("SPEED"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("CODE_SIZE"), + Number: func(v int32) *int32 { return &v }(2), + }, {Name: func(v string) *string { return &v }("LITE_RUNTIME"), + Number: func(v int32) *int32 { return &v }(3), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MessageOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("message_set_wire_format"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("no_standard_descriptor_accessor"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("map_entry"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("FieldOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("ctype"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(14), + TypeName: func(v string) *string { return &v }(".google.protobuf.FieldOptions.CType"), + DefaultValue: func(v string) *string { return &v }("STRING"), + }, {Name: func(v string) *string { return &v }("packed"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("lazy"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("weak"), + Number: func(v int32) *int32 { return &v }(10), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + EnumType: []*google_protobuf.EnumDescriptorProto{{Name: func(v string) *string { return &v }("CType"), + Value: []*google_protobuf.EnumValueDescriptorProto{{Name: func(v string) *string { return &v }("STRING"), + Number: func(v int32) *int32 { return &v }(0), + }, {Name: func(v string) *string { return &v }("CORD"), + Number: func(v int32) *int32 { return &v }(1), + }, {Name: func(v string) *string { return &v }("STRING_PIECE"), + Number: func(v int32) *int32 { return &v }(2), + }}, + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("allow_alias"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }, {Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("EnumValueOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("ServiceOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("MethodOptions"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("deprecated"), + Number: func(v int32) *int32 { return &v }(33), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + DefaultValue: func(v string) *string { return &v }("false"), + }, {Name: func(v string) *string { return &v }("uninterpreted_option"), + Number: func(v int32) *int32 { return &v }(999), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption"), + }}, + ExtensionRange: []*google_protobuf.DescriptorProto_ExtensionRange{{Start: func(v int32) *int32 { return &v }(1000), + End: func(v int32) *int32 { return &v }(536870912), + }}, + }, {Name: func(v string) *string { return &v }("UninterpretedOption"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.UninterpretedOption.NamePart"), + }, {Name: func(v string) *string { return &v }("identifier_value"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("positive_int_value"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(4), + }, {Name: func(v string) *string { return &v }("negative_int_value"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("double_value"), + Number: func(v int32) *int32 { return &v }(6), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("string_value"), + Number: func(v int32) *int32 { return &v }(7), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(12), + }, {Name: func(v string) *string { return &v }("aggregate_value"), + Number: func(v int32) *int32 { return &v }(8), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NamePart"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("name_part"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("is_extension"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(2), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + }}, + }}, + }, {Name: func(v string) *string { return &v }("SourceCodeInfo"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("location"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".google.protobuf.SourceCodeInfo.Location"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Location"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("path"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("span"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + Options: &google_protobuf.FieldOptions{Packed: func(v bool) *bool { return &v }(true), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("leading_comments"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }, {Name: func(v string) *string { return &v }("trailing_comments"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("DescriptorProtos"), + OptimizeFor: func(v google_protobuf.FileOptions_OptimizeMode) *google_protobuf.FileOptions_OptimizeMode { return &v }(1), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("github.com/gogo/protobuf/gogoproto/gogo.proto"), + Package: func(v string) *string { return &v }("gogoproto"), + Dependency: []string{"google/protobuf/descriptor.proto"}, + Extension: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("goproto_enum_prefix"), + Number: func(v int32) *int32 { return &v }(62001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer"), + Number: func(v int32) *int32 { return &v }(62021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer"), + Number: func(v int32) *int32 { return &v }(62022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.EnumOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters_all"), + Number: func(v int32) *int32 { return &v }(63001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_prefix_all"), + Number: func(v int32) *int32 { return &v }(63002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer_all"), + Number: func(v int32) *int32 { return &v }(63003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal_all"), + Number: func(v int32) *int32 { return &v }(63004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("face_all"), + Number: func(v int32) *int32 { return &v }(63005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gostring_all"), + Number: func(v int32) *int32 { return &v }(63006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("populate_all"), + Number: func(v int32) *int32 { return &v }(63007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("stringer_all"), + Number: func(v int32) *int32 { return &v }(63008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("onlyone_all"), + Number: func(v int32) *int32 { return &v }(63009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("equal_all"), + Number: func(v int32) *int32 { return &v }(63013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("description_all"), + Number: func(v int32) *int32 { return &v }(63014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("testgen_all"), + Number: func(v int32) *int32 { return &v }(63015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("benchgen_all"), + Number: func(v int32) *int32 { return &v }(63016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("marshaler_all"), + Number: func(v int32) *int32 { return &v }(63017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("sizer_all"), + Number: func(v int32) *int32 { return &v }(63020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63021), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("enum_stringer_all"), + Number: func(v int32) *int32 { return &v }(63022), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler_all"), + Number: func(v int32) *int32 { return &v }(63023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler_all"), + Number: func(v int32) *int32 { return &v }(63024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map_all"), + Number: func(v int32) *int32 { return &v }(63025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized_all"), + Number: func(v int32) *int32 { return &v }(63026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("gogoproto_import"), + Number: func(v int32) *int32 { return &v }(63027), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FileOptions"), + }, {Name: func(v string) *string { return &v }("goproto_getters"), + Number: func(v int32) *int32 { return &v }(64001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_stringer"), + Number: func(v int32) *int32 { return &v }(64003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("verbose_equal"), + Number: func(v int32) *int32 { return &v }(64004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("face"), + Number: func(v int32) *int32 { return &v }(64005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("gostring"), + Number: func(v int32) *int32 { return &v }(64006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("populate"), + Number: func(v int32) *int32 { return &v }(64007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("stringer"), + Number: func(v int32) *int32 { return &v }(67008), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("onlyone"), + Number: func(v int32) *int32 { return &v }(64009), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("equal"), + Number: func(v int32) *int32 { return &v }(64013), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("description"), + Number: func(v int32) *int32 { return &v }(64014), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("testgen"), + Number: func(v int32) *int32 { return &v }(64015), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("benchgen"), + Number: func(v int32) *int32 { return &v }(64016), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("marshaler"), + Number: func(v int32) *int32 { return &v }(64017), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unmarshaler"), + Number: func(v int32) *int32 { return &v }(64018), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("sizer"), + Number: func(v int32) *int32 { return &v }(64020), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_marshaler"), + Number: func(v int32) *int32 { return &v }(64023), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("unsafe_unmarshaler"), + Number: func(v int32) *int32 { return &v }(64024), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_extensions_map"), + Number: func(v int32) *int32 { return &v }(64025), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("goproto_unrecognized"), + Number: func(v int32) *int32 { return &v }(64026), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.MessageOptions"), + }, {Name: func(v string) *string { return &v }("nullable"), + Number: func(v int32) *int32 { return &v }(65001), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("embed"), + Number: func(v int32) *int32 { return &v }(65002), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(8), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customtype"), + Number: func(v int32) *int32 { return &v }(65003), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("customname"), + Number: func(v int32) *int32 { return &v }(65004), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("jsontag"), + Number: func(v int32) *int32 { return &v }(65005), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("moretags"), + Number: func(v int32) *int32 { return &v }(65006), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }, {Name: func(v string) *string { return &v }("casttype"), + Number: func(v int32) *int32 { return &v }(65007), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(9), + Extendee: func(v string) *string { return &v }(".google.protobuf.FieldOptions"), + }}, + Options: &google_protobuf.FileOptions{JavaPackage: func(v string) *string { return &v }("com.google.protobuf"), + JavaOuterClassname: func(v string) *string { return &v }("GoGoProtos"), + XXX_extensions: map[int32]proto.Extension{}, + }, + }, {Name: func(v string) *string { return &v }("unrecognizedgroup.proto"), + Package: func(v string) *string { return &v }("unrecognizedgroup"), + Dependency: []string{"github.com/gogo/protobuf/gogoproto/gogo.proto"}, + MessageType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("NewNoGroup"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("A"), + Number: func(v int32) *int32 { return &v }(5), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(11), + TypeName: func(v string) *string { return &v }(".unrecognizedgroup.A"), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64017: proto.NewExtension([]byte{0x88, 0xa1, 0x1f, 0x1}), 64018: proto.NewExtension([]byte{0x90, 0xa1, 0x1f, 0x1}), 64020: proto.NewExtension([]byte{0xa0, 0xa1, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("A"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("AField"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }}, + Options: &google_protobuf.MessageOptions{XXX_extensions: map[int32]proto.Extension{64017: proto.NewExtension([]byte{0x88, 0xa1, 0x1f, 0x1}), 64018: proto.NewExtension([]byte{0x90, 0xa1, 0x1f, 0x1}), 64020: proto.NewExtension([]byte{0xa0, 0xa1, 0x1f, 0x1})}}, + }, {Name: func(v string) *string { return &v }("OldWithGroup"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("group1"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(10), + TypeName: func(v string) *string { return &v }(".unrecognizedgroup.OldWithGroup.Group1"), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }, {Name: func(v string) *string { return &v }("group2"), + Number: func(v int32) *int32 { return &v }(4), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(10), + TypeName: func(v string) *string { return &v }(".unrecognizedgroup.OldWithGroup.Group2"), + }}, + NestedType: []*google_protobuf.DescriptorProto{{Name: func(v string) *string { return &v }("Group1"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(5), + }, {Name: func(v string) *string { return &v }("Field3"), + Number: func(v int32) *int32 { return &v }(3), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }, {Name: func(v string) *string { return &v }("Group2"), + Field: []*google_protobuf.FieldDescriptorProto{{Name: func(v string) *string { return &v }("Field1"), + Number: func(v int32) *int32 { return &v }(1), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(1), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(3), + }, {Name: func(v string) *string { return &v }("Field2"), + Number: func(v int32) *int32 { return &v }(2), + Label: func(v google_protobuf.FieldDescriptorProto_Label) *google_protobuf.FieldDescriptorProto_Label { + return &v + }(3), + Type: func(v google_protobuf.FieldDescriptorProto_Type) *google_protobuf.FieldDescriptorProto_Type { + return &v + }(1), + }}, + }}, + }}, + Options: &google_protobuf.FileOptions{XXX_extensions: map[int32]proto.Extension{63001: proto.NewExtension([]byte{0xc8, 0xe1, 0x1e, 0x0}), 63002: proto.NewExtension([]byte{0xd0, 0xe1, 0x1e, 0x0}), 63003: proto.NewExtension([]byte{0xd8, 0xe1, 0x1e, 0x0}), 63004: proto.NewExtension([]byte{0xe0, 0xe1, 0x1e, 0x1}), 63006: proto.NewExtension([]byte{0xf0, 0xe1, 0x1e, 0x1}), 63007: proto.NewExtension([]byte{0xf8, 0xe1, 0x1e, 0x1}), 63008: proto.NewExtension([]byte{0x80, 0xe2, 0x1e, 0x1}), 63013: proto.NewExtension([]byte{0xa8, 0xe2, 0x1e, 0x1}), 63014: proto.NewExtension([]byte{0xb0, 0xe2, 0x1e, 0x1}), 63015: proto.NewExtension([]byte{0xb8, 0xe2, 0x1e, 0x1})}}, + }}, + } +} +func (this *NewNoGroup) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*NewNoGroup) + if !ok { + return fmt.Errorf("that is not of type *NewNoGroup") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *NewNoGroup but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *NewNoGroupbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if !this.A.Equal(that1.A) { + return fmt.Errorf("A this(%v) Not Equal that(%v)", this.A, that1.A) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *NewNoGroup) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*NewNoGroup) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if !this.A.Equal(that1.A) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *A) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*A) + if !ok { + return fmt.Errorf("that is not of type *A") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *A but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *Abut is not nil && this == nil") + } + if this.AField != nil && that1.AField != nil { + if *this.AField != *that1.AField { + return fmt.Errorf("AField this(%v) Not Equal that(%v)", *this.AField, *that1.AField) + } + } else if this.AField != nil { + return fmt.Errorf("this.AField == nil && that.AField != nil") + } else if that1.AField != nil { + return fmt.Errorf("AField this(%v) Not Equal that(%v)", this.AField, that1.AField) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *A) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*A) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.AField != nil && that1.AField != nil { + if *this.AField != *that1.AField { + return false + } + } else if this.AField != nil { + return false + } else if that1.AField != nil { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OldWithGroup) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OldWithGroup) + if !ok { + return fmt.Errorf("that is not of type *OldWithGroup") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OldWithGroup but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OldWithGroupbut is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if !this.Group1.Equal(that1.Group1) { + return fmt.Errorf("Group1 this(%v) Not Equal that(%v)", this.Group1, that1.Group1) + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if !this.Group2.Equal(that1.Group2) { + return fmt.Errorf("Group2 this(%v) Not Equal that(%v)", this.Group2, that1.Group2) + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OldWithGroup) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OldWithGroup) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if !this.Group1.Equal(that1.Group1) { + return false + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if !this.Group2.Equal(that1.Group2) { + return false + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OldWithGroup_Group1) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OldWithGroup_Group1) + if !ok { + return fmt.Errorf("that is not of type *OldWithGroup_Group1") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OldWithGroup_Group1 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OldWithGroup_Group1but is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", *this.Field2, *that1.Field2) + } + } else if this.Field2 != nil { + return fmt.Errorf("this.Field2 == nil && that.Field2 != nil") + } else if that1.Field2 != nil { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", this.Field2, that1.Field2) + } + if len(this.Field3) != len(that1.Field3) { + return fmt.Errorf("Field3 this(%v) Not Equal that(%v)", len(this.Field3), len(that1.Field3)) + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return fmt.Errorf("Field3 this[%v](%v) Not Equal that[%v](%v)", i, this.Field3[i], i, that1.Field3[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OldWithGroup_Group1) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OldWithGroup_Group1) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if this.Field2 != nil && that1.Field2 != nil { + if *this.Field2 != *that1.Field2 { + return false + } + } else if this.Field2 != nil { + return false + } else if that1.Field2 != nil { + return false + } + if len(this.Field3) != len(that1.Field3) { + return false + } + for i := range this.Field3 { + if this.Field3[i] != that1.Field3[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *OldWithGroup_Group2) VerboseEqual(that interface{}) error { + if that == nil { + if this == nil { + return nil + } + return fmt.Errorf("that == nil && this != nil") + } + + that1, ok := that.(*OldWithGroup_Group2) + if !ok { + return fmt.Errorf("that is not of type *OldWithGroup_Group2") + } + if that1 == nil { + if this == nil { + return nil + } + return fmt.Errorf("that is type *OldWithGroup_Group2 but is nil && this != nil") + } else if this == nil { + return fmt.Errorf("that is type *OldWithGroup_Group2but is not nil && this == nil") + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", *this.Field1, *that1.Field1) + } + } else if this.Field1 != nil { + return fmt.Errorf("this.Field1 == nil && that.Field1 != nil") + } else if that1.Field1 != nil { + return fmt.Errorf("Field1 this(%v) Not Equal that(%v)", this.Field1, that1.Field1) + } + if len(this.Field2) != len(that1.Field2) { + return fmt.Errorf("Field2 this(%v) Not Equal that(%v)", len(this.Field2), len(that1.Field2)) + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return fmt.Errorf("Field2 this[%v](%v) Not Equal that[%v](%v)", i, this.Field2[i], i, that1.Field2[i]) + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized) + } + return nil +} +func (this *OldWithGroup_Group2) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*OldWithGroup_Group2) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Field1 != nil && that1.Field1 != nil { + if *this.Field1 != *that1.Field1 { + return false + } + } else if this.Field1 != nil { + return false + } else if that1.Field1 != nil { + return false + } + if len(this.Field2) != len(that1.Field2) { + return false + } + for i := range this.Field2 { + if this.Field2[i] != that1.Field2[i] { + return false + } + } + if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { + return false + } + return true +} +func (this *NewNoGroup) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&unrecognizedgroup.NewNoGroup{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringUnrecognizedgroup(this.Field1, "int64")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.A != nil { + s = append(s, "A: "+fmt.Sprintf("%#v", this.A)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *A) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&unrecognizedgroup.A{") + if this.AField != nil { + s = append(s, "AField: "+valueToGoStringUnrecognizedgroup(this.AField, "int64")+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OldWithGroup) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 8) + s = append(s, "&unrecognizedgroup.OldWithGroup{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringUnrecognizedgroup(this.Field1, "int64")+",\n") + } + if this.Group1 != nil { + s = append(s, "Group1: "+fmt.Sprintf("%#v", this.Group1)+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.Group2 != nil { + s = append(s, "Group2: "+fmt.Sprintf("%#v", this.Group2)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OldWithGroup_Group1) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&unrecognizedgroup.OldWithGroup_Group1{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringUnrecognizedgroup(this.Field1, "int64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+valueToGoStringUnrecognizedgroup(this.Field2, "int32")+",\n") + } + if this.Field3 != nil { + s = append(s, "Field3: "+fmt.Sprintf("%#v", this.Field3)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *OldWithGroup_Group2) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&unrecognizedgroup.OldWithGroup_Group2{") + if this.Field1 != nil { + s = append(s, "Field1: "+valueToGoStringUnrecognizedgroup(this.Field1, "int64")+",\n") + } + if this.Field2 != nil { + s = append(s, "Field2: "+fmt.Sprintf("%#v", this.Field2)+",\n") + } + if this.XXX_unrecognized != nil { + s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringUnrecognizedgroup(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringUnrecognizedgroup(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *NewNoGroup) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *NewNoGroup) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Field1 != nil { + data[i] = 0x8 + i++ + i = encodeVarintUnrecognizedgroup(data, i, uint64(*m.Field1)) + } + if len(m.Field3) > 0 { + for _, num := range m.Field3 { + data[i] = 0x19 + i++ + f1 := math.Float64bits(num) + data[i] = uint8(f1) + i++ + data[i] = uint8(f1 >> 8) + i++ + data[i] = uint8(f1 >> 16) + i++ + data[i] = uint8(f1 >> 24) + i++ + data[i] = uint8(f1 >> 32) + i++ + data[i] = uint8(f1 >> 40) + i++ + data[i] = uint8(f1 >> 48) + i++ + data[i] = uint8(f1 >> 56) + i++ + } + } + if m.A != nil { + data[i] = 0x2a + i++ + i = encodeVarintUnrecognizedgroup(data, i, uint64(m.A.Size())) + n2, err := m.A.MarshalTo(data[i:]) + if err != nil { + return 0, err + } + i += n2 + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *A) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *A) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.AField != nil { + data[i] = 0x8 + i++ + i = encodeVarintUnrecognizedgroup(data, i, uint64(*m.AField)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Unrecognizedgroup(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Unrecognizedgroup(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintUnrecognizedgroup(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func NewPopulatedNewNoGroup(r randyUnrecognizedgroup, easy bool) *NewNoGroup { + this := &NewNoGroup{} + if r.Intn(10) != 0 { + v1 := int64(r.Int63()) + if r.Intn(2) == 0 { + v1 *= -1 + } + this.Field1 = &v1 + } + if r.Intn(10) != 0 { + v2 := r.Intn(100) + this.Field3 = make([]float64, v2) + for i := 0; i < v2; i++ { + this.Field3[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + this.A = NewPopulatedA(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedUnrecognizedgroup(r, 6) + } + return this +} + +func NewPopulatedA(r randyUnrecognizedgroup, easy bool) *A { + this := &A{} + if r.Intn(10) != 0 { + v3 := int64(r.Int63()) + if r.Intn(2) == 0 { + v3 *= -1 + } + this.AField = &v3 + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedUnrecognizedgroup(r, 2) + } + return this +} + +func NewPopulatedOldWithGroup(r randyUnrecognizedgroup, easy bool) *OldWithGroup { + this := &OldWithGroup{} + if r.Intn(10) != 0 { + v4 := int64(r.Int63()) + if r.Intn(2) == 0 { + v4 *= -1 + } + this.Field1 = &v4 + } + if r.Intn(10) != 0 { + this.Group1 = NewPopulatedOldWithGroup_Group1(r, easy) + } + if r.Intn(10) != 0 { + v5 := r.Intn(100) + this.Field3 = make([]float64, v5) + for i := 0; i < v5; i++ { + this.Field3[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if r.Intn(10) != 0 { + this.Group2 = NewPopulatedOldWithGroup_Group2(r, easy) + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedUnrecognizedgroup(r, 5) + } + return this +} + +func NewPopulatedOldWithGroup_Group1(r randyUnrecognizedgroup, easy bool) *OldWithGroup_Group1 { + this := &OldWithGroup_Group1{} + if r.Intn(10) != 0 { + v6 := int64(r.Int63()) + if r.Intn(2) == 0 { + v6 *= -1 + } + this.Field1 = &v6 + } + if r.Intn(10) != 0 { + v7 := int32(r.Int31()) + if r.Intn(2) == 0 { + v7 *= -1 + } + this.Field2 = &v7 + } + if r.Intn(10) != 0 { + v8 := r.Intn(100) + this.Field3 = make([]float64, v8) + for i := 0; i < v8; i++ { + this.Field3[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field3[i] *= -1 + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedUnrecognizedgroup(r, 4) + } + return this +} + +func NewPopulatedOldWithGroup_Group2(r randyUnrecognizedgroup, easy bool) *OldWithGroup_Group2 { + this := &OldWithGroup_Group2{} + if r.Intn(10) != 0 { + v9 := int64(r.Int63()) + if r.Intn(2) == 0 { + v9 *= -1 + } + this.Field1 = &v9 + } + if r.Intn(10) != 0 { + v10 := r.Intn(100) + this.Field2 = make([]float64, v10) + for i := 0; i < v10; i++ { + this.Field2[i] = float64(r.Float64()) + if r.Intn(2) == 0 { + this.Field2[i] *= -1 + } + } + } + if !easy && r.Intn(10) != 0 { + this.XXX_unrecognized = randUnrecognizedUnrecognizedgroup(r, 3) + } + return this +} + +type randyUnrecognizedgroup interface { + Float32() float32 + Float64() float64 + Int63() int64 + Int31() int32 + Uint32() uint32 + Intn(n int) int +} + +func randUTF8RuneUnrecognizedgroup(r randyUnrecognizedgroup) rune { + ru := r.Intn(62) + if ru < 10 { + return rune(ru + 48) + } else if ru < 36 { + return rune(ru + 55) + } + return rune(ru + 61) +} +func randStringUnrecognizedgroup(r randyUnrecognizedgroup) string { + v11 := r.Intn(100) + tmps := make([]rune, v11) + for i := 0; i < v11; i++ { + tmps[i] = randUTF8RuneUnrecognizedgroup(r) + } + return string(tmps) +} +func randUnrecognizedUnrecognizedgroup(r randyUnrecognizedgroup, maxFieldNumber int) (data []byte) { + l := r.Intn(5) + for i := 0; i < l; i++ { + wire := r.Intn(4) + if wire == 3 { + wire = 5 + } + fieldNumber := maxFieldNumber + r.Intn(100) + data = randFieldUnrecognizedgroup(data, r, fieldNumber, wire) + } + return data +} +func randFieldUnrecognizedgroup(data []byte, r randyUnrecognizedgroup, fieldNumber int, wire int) []byte { + key := uint32(fieldNumber)<<3 | uint32(wire) + switch wire { + case 0: + data = encodeVarintPopulateUnrecognizedgroup(data, uint64(key)) + v12 := r.Int63() + if r.Intn(2) == 0 { + v12 *= -1 + } + data = encodeVarintPopulateUnrecognizedgroup(data, uint64(v12)) + case 1: + data = encodeVarintPopulateUnrecognizedgroup(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + case 2: + data = encodeVarintPopulateUnrecognizedgroup(data, uint64(key)) + ll := r.Intn(100) + data = encodeVarintPopulateUnrecognizedgroup(data, uint64(ll)) + for j := 0; j < ll; j++ { + data = append(data, byte(r.Intn(256))) + } + default: + data = encodeVarintPopulateUnrecognizedgroup(data, uint64(key)) + data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) + } + return data +} +func encodeVarintPopulateUnrecognizedgroup(data []byte, v uint64) []byte { + for v >= 1<<7 { + data = append(data, uint8(uint64(v)&0x7f|0x80)) + v >>= 7 + } + data = append(data, uint8(v)) + return data +} +func (m *NewNoGroup) Size() (n int) { + var l int + _ = l + if m.Field1 != nil { + n += 1 + sovUnrecognizedgroup(uint64(*m.Field1)) + } + if len(m.Field3) > 0 { + n += 9 * len(m.Field3) + } + if m.A != nil { + l = m.A.Size() + n += 1 + l + sovUnrecognizedgroup(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *A) Size() (n int) { + var l int + _ = l + if m.AField != nil { + n += 1 + sovUnrecognizedgroup(uint64(*m.AField)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovUnrecognizedgroup(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozUnrecognizedgroup(x uint64) (n int) { + return sovUnrecognizedgroup(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *NewNoGroup) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&NewNoGroup{`, + `Field1:` + valueToStringUnrecognizedgroup(this.Field1) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `A:` + strings.Replace(fmt.Sprintf("%v", this.A), "A", "A", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *A) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&A{`, + `AField:` + valueToStringUnrecognizedgroup(this.AField) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OldWithGroup) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OldWithGroup{`, + `Field1:` + valueToStringUnrecognizedgroup(this.Field1) + `,`, + `Group1:` + strings.Replace(fmt.Sprintf("%v", this.Group1), "OldWithGroup_Group1", "OldWithGroup_Group1", 1) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `Group2:` + strings.Replace(fmt.Sprintf("%v", this.Group2), "OldWithGroup_Group2", "OldWithGroup_Group2", 1) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OldWithGroup_Group1) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OldWithGroup_Group1{`, + `Field1:` + valueToStringUnrecognizedgroup(this.Field1) + `,`, + `Field2:` + valueToStringUnrecognizedgroup(this.Field2) + `,`, + `Field3:` + fmt.Sprintf("%v", this.Field3) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func (this *OldWithGroup_Group2) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&OldWithGroup_Group2{`, + `Field1:` + valueToStringUnrecognizedgroup(this.Field1) + `,`, + `Field2:` + fmt.Sprintf("%v", this.Field2) + `,`, + `XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`, + `}`, + }, "") + return s +} +func valueToStringUnrecognizedgroup(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *NewNoGroup) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognizedgroup + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NewNoGroup: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NewNoGroup: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Field1", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognizedgroup + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Field1 = &v + case 3: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Field3", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + iNdEx += 8 + v = uint64(data[iNdEx-8]) + v |= uint64(data[iNdEx-7]) << 8 + v |= uint64(data[iNdEx-6]) << 16 + v |= uint64(data[iNdEx-5]) << 24 + v |= uint64(data[iNdEx-4]) << 32 + v |= uint64(data[iNdEx-3]) << 40 + v |= uint64(data[iNdEx-2]) << 48 + v |= uint64(data[iNdEx-1]) << 56 + v2 := float64(math.Float64frombits(v)) + m.Field3 = append(m.Field3, v2) + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field A", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognizedgroup + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthUnrecognizedgroup + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.A == nil { + m.A = &A{} + } + if err := m.A.Unmarshal(data[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipUnrecognizedgroup(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthUnrecognizedgroup + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *A) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognizedgroup + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: A: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: A: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AField", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowUnrecognizedgroup + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.AField = &v + default: + iNdEx = preIndex + skippy, err := skipUnrecognizedgroup(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthUnrecognizedgroup + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipUnrecognizedgroup(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowUnrecognizedgroup + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowUnrecognizedgroup + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowUnrecognizedgroup + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthUnrecognizedgroup + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowUnrecognizedgroup + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipUnrecognizedgroup(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthUnrecognizedgroup = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowUnrecognizedgroup = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognizedgroup/unrecognizedgroup.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognizedgroup/unrecognizedgroup.proto new file mode 100644 index 0000000000000000000000000000000000000000..0a33cbc9fec4c0da8b1006dd7f4ce7dc9469d868 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognizedgroup/unrecognizedgroup.proto @@ -0,0 +1,75 @@ +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package unrecognizedgroup; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +option (gogoproto.goproto_stringer_all) = false; +option (gogoproto.goproto_enum_prefix_all) = false; +option (gogoproto.goproto_getters_all) = false; + +option (gogoproto.equal_all) = true; +option (gogoproto.verbose_equal_all) = true; +option (gogoproto.stringer_all) = true; +option (gogoproto.gostring_all) = true; +option (gogoproto.description_all) = true; + +option (gogoproto.testgen_all) = true; +option (gogoproto.populate_all) = true; + +message NewNoGroup { + option (gogoproto.unmarshaler) = true; + option (gogoproto.marshaler) = true; + option (gogoproto.sizer) = true; + optional int64 Field1 = 1; + repeated double Field3 = 3; + optional A A = 5; +} + +message A { + option (gogoproto.unmarshaler) = true; + option (gogoproto.marshaler) = true; + option (gogoproto.sizer) = true; + optional int64 AField = 1; +} + +message OldWithGroup { + optional int64 Field1 = 1; + optional group Group1 = 2 { + optional int64 Field1 = 1; + optional int32 Field2 = 2; + repeated double Field3 = 3; + } + repeated double Field3 = 3; + optional group Group2 = 4 { + optional int64 Field1 = 1; + repeated double Field2 = 2; + } +} + diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognizedgroup/unrecognizedgrouppb_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognizedgroup/unrecognizedgrouppb_test.go new file mode 100644 index 0000000000000000000000000000000000000000..14dde08678d5535f6527619e03e7fef36545e687 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/unrecognizedgroup/unrecognizedgrouppb_test.go @@ -0,0 +1,769 @@ +// Code generated by protoc-gen-gogo. +// source: unrecognizedgroup.proto +// DO NOT EDIT! + +/* +Package unrecognizedgroup is a generated protocol buffer package. + +It is generated from these files: + unrecognizedgroup.proto + +It has these top-level messages: + NewNoGroup + A + OldWithGroup +*/ +package unrecognizedgroup + +import testing "testing" +import math_rand "math/rand" +import time "time" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import github_com_gogo_protobuf_jsonpb "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/jsonpb" +import fmt "fmt" +import go_parser "go/parser" +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +func TestNewNoGroupProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNewNoGroup(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NewNoGroup{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNewNoGroupMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNewNoGroup(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NewNoGroup{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &A{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestAMarshalTo(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, false) + size := p.Size() + data := make([]byte, size) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + _, err := p.MarshalTo(data) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &A{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldWithGroupProto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldWithGroup(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldWithGroup{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestOldWithGroup_Group1Proto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldWithGroup_Group1(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldWithGroup_Group1{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestOldWithGroup_Group2Proto(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldWithGroup_Group2(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldWithGroup_Group2{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + littlefuzz := make([]byte, len(data)) + copy(littlefuzz, data) + for i := range data { + data[i] = byte(popr.Intn(256)) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } + if len(littlefuzz) > 0 { + fuzzamount := 100 + for i := 0; i < fuzzamount; i++ { + littlefuzz[popr.Intn(len(littlefuzz))] = byte(popr.Intn(256)) + littlefuzz = append(littlefuzz, byte(popr.Intn(256))) + } + // shouldn't panic + _ = github_com_gogo_protobuf_proto.Unmarshal(littlefuzz, msg) + } +} + +func TestNewNoGroupJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNewNoGroup(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &NewNoGroup{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestAJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &A{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOldWithGroupJSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldWithGroup(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldWithGroup{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOldWithGroup_Group1JSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldWithGroup_Group1(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldWithGroup_Group1{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestOldWithGroup_Group2JSON(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldWithGroup_Group2(popr, true) + marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{} + jsondata, err := marshaler.MarshalToString(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + msg := &OldWithGroup_Group2{} + err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p) + } +} +func TestNewNoGroupProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNewNoGroup(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &NewNoGroup{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestNewNoGroupProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNewNoGroup(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &NewNoGroup{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &A{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestAProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &A{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldWithGroupProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldWithGroup(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OldWithGroup{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldWithGroupProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldWithGroup(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OldWithGroup{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldWithGroup_Group1ProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldWithGroup_Group1(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OldWithGroup_Group1{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldWithGroup_Group1ProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldWithGroup_Group1(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OldWithGroup_Group1{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldWithGroup_Group2ProtoText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldWithGroup_Group2(popr, true) + data := github_com_gogo_protobuf_proto.MarshalTextString(p) + msg := &OldWithGroup_Group2{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestOldWithGroup_Group2ProtoCompactText(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedOldWithGroup_Group2(popr, true) + data := github_com_gogo_protobuf_proto.CompactTextString(p) + msg := &OldWithGroup_Group2{} + if err := github_com_gogo_protobuf_proto.UnmarshalText(data, msg); err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("seed = %d, %#v !VerboseProto %#v, since %v", seed, msg, p, err) + } + if !p.Equal(msg) { + t.Fatalf("seed = %d, %#v !Proto %#v", seed, msg, p) + } +} + +func TestUnrecognizedgroupDescription(t *testing.T) { + UnrecognizedgroupDescription() +} +func TestNewNoGroupVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNewNoGroup(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &NewNoGroup{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestAVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedA(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &A{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOldWithGroupVerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldWithGroup(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OldWithGroup{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOldWithGroup_Group1VerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldWithGroup_Group1(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OldWithGroup_Group1{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestOldWithGroup_Group2VerboseEqual(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldWithGroup_Group2(popr, false) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + panic(err) + } + msg := &OldWithGroup_Group2{} + if err := github_com_gogo_protobuf_proto.Unmarshal(data, msg); err != nil { + panic(err) + } + if err := p.VerboseEqual(msg); err != nil { + t.Fatalf("%#v !VerboseEqual %#v, since %v", msg, p, err) + } +} +func TestNewNoGroupGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNewNoGroup(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestAGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedA(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOldWithGroupGoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldWithGroup(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOldWithGroup_Group1GoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldWithGroup_Group1(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestOldWithGroup_Group2GoString(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldWithGroup_Group2(popr, false) + s1 := p.GoString() + s2 := fmt.Sprintf("%#v", p) + if s1 != s2 { + t.Fatalf("GoString want %v got %v", s1, s2) + } + _, err := go_parser.ParseExpr(s1) + if err != nil { + panic(err) + } +} +func TestNewNoGroupSize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedNewNoGroup(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestASize(t *testing.T) { + seed := time.Now().UnixNano() + popr := math_rand.New(math_rand.NewSource(seed)) + p := NewPopulatedA(popr, true) + size2 := github_com_gogo_protobuf_proto.Size(p) + data, err := github_com_gogo_protobuf_proto.Marshal(p) + if err != nil { + t.Fatalf("seed = %d, err = %v", seed, err) + } + size := p.Size() + if len(data) != size { + t.Errorf("seed = %d, size %v != marshalled size %v", seed, size, len(data)) + } + if size2 != size { + t.Errorf("seed = %d, size %v != before marshal proto.Size %v", seed, size, size2) + } + size3 := github_com_gogo_protobuf_proto.Size(p) + if size3 != size { + t.Errorf("seed = %d, size %v != after marshal proto.Size %v", seed, size, size3) + } +} + +func TestNewNoGroupStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedNewNoGroup(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestAStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedA(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOldWithGroupStringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldWithGroup(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOldWithGroup_Group1Stringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldWithGroup_Group1(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} +func TestOldWithGroup_Group2Stringer(t *testing.T) { + popr := math_rand.New(math_rand.NewSource(time.Now().UnixNano())) + p := NewPopulatedOldWithGroup_Group2(popr, false) + s1 := p.String() + s2 := fmt.Sprintf("%v", p) + if s1 != s2 { + t.Fatalf("String want %v got %v", s1, s2) + } +} + +//These tests are generated by github.com/gogo/protobuf/plugin/testgen diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/uuid.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/uuid.go new file mode 100644 index 0000000000000000000000000000000000000000..4c071114bcce237893cd1f0fa4baca9d8663b571 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/uuid.go @@ -0,0 +1,122 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 test + +import ( + "bytes" + "encoding/json" +) + +func PutLittleEndianUint64(b []byte, offset int, v uint64) { + b[offset] = byte(v) + b[offset+1] = byte(v >> 8) + b[offset+2] = byte(v >> 16) + b[offset+3] = byte(v >> 24) + b[offset+4] = byte(v >> 32) + b[offset+5] = byte(v >> 40) + b[offset+6] = byte(v >> 48) + b[offset+7] = byte(v >> 56) +} + +type Uuid []byte + +func (uuid Uuid) Marshal() ([]byte, error) { + if len(uuid) == 0 { + return nil, nil + } + return []byte(uuid), nil +} + +func (uuid Uuid) MarshalTo(data []byte) (n int, err error) { + if len(uuid) == 0 { + return 0, nil + } + copy(data, uuid) + return 16, nil +} + +func (uuid *Uuid) Unmarshal(data []byte) error { + if len(data) == 0 { + uuid = nil + return nil + } + id := Uuid(make([]byte, 16)) + copy(id, data) + *uuid = id + return nil +} + +func (uuid *Uuid) Size() int { + if uuid == nil { + return 0 + } + if len(*uuid) == 0 { + return 0 + } + return 16 +} + +func (uuid Uuid) MarshalJSON() ([]byte, error) { + return json.Marshal([]byte(uuid)) +} + +func (uuid *Uuid) UnmarshalJSON(data []byte) error { + v := new([]byte) + err := json.Unmarshal(data, v) + if err != nil { + return err + } + return uuid.Unmarshal(*v) +} + +func (uuid Uuid) Equal(other Uuid) bool { + return bytes.Equal(uuid[0:], other[0:]) +} + +type int63 interface { + Int63() int64 +} + +func NewPopulatedUuid(r int63) *Uuid { + u := RandV4(r) + return &u +} + +func RandV4(r int63) Uuid { + uuid := make(Uuid, 16) + uuid.RandV4(r) + return uuid +} + +func (uuid Uuid) RandV4(r int63) { + PutLittleEndianUint64(uuid, 0, uint64(r.Int63())) + PutLittleEndianUint64(uuid, 8, uint64(r.Int63())) + uuid[6] = (uuid[6] & 0xf) | 0x40 + uuid[8] = (uuid[8] & 0x3f) | 0x80 +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/uuid_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/uuid_test.go new file mode 100644 index 0000000000000000000000000000000000000000..3c615a720c9be9a198b75fb6454ca866c0a56782 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/test/uuid_test.go @@ -0,0 +1,23 @@ +package test + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "testing" +) + +func TestBugUuid(t *testing.T) { + u := &CustomContainer{CustomStruct: NidOptCustom{Id: Uuid{}}} + data, err := proto.Marshal(u) + if err != nil { + panic(err) + } + u2 := &CustomContainer{} + err = proto.Unmarshal(data, u2) + if err != nil { + panic(err) + } + t.Logf("%+v", u2) + if u2.CustomStruct.Id != nil { + t.Fatalf("should be nil") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/command/command.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/command/command.go new file mode 100644 index 0000000000000000000000000000000000000000..f58f2e329e7e9014638bd7b210303569b16234d6 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/command/command.go @@ -0,0 +1,151 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 command + +import ( + "io/ioutil" + "os" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/generator" + plugin "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/plugin" + + _ "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/grpc" + + _ "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/defaultcheck" + _ "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/description" + _ "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/embedcheck" + _ "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/enumstringer" + _ "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/equal" + _ "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/face" + _ "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/gostring" + _ "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/marshalto" + _ "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/oneofcheck" + _ "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/populate" + _ "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/size" + _ "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/stringer" + _ "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/union" + _ "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/unmarshal" + + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/plugin/testgen" + + "go/format" + "strings" +) + +func Read() *plugin.CodeGeneratorRequest { + g := generator.New() + data, err := ioutil.ReadAll(os.Stdin) + if err != nil { + g.Error(err, "reading input") + } + + if err := proto.Unmarshal(data, g.Request); err != nil { + g.Error(err, "parsing input proto") + } + + if len(g.Request.FileToGenerate) == 0 { + g.Fail("no files to generate") + } + return g.Request +} + +func Generate(req *plugin.CodeGeneratorRequest) *plugin.CodeGeneratorResponse { + // Begin by allocating a generator. The request and response structures are stored there + // so we can do error handling easily - the response structure contains the field to + // report failure. + g := generator.New() + g.Request = req + + g.CommandLineParameters(g.Request.GetParameter()) + + // Create a wrapped version of the Descriptors and EnumDescriptors that + // point to the file that defines them. + g.WrapTypes() + + g.SetPackageNames() + g.BuildTypeNameMap() + + g.GenerateAllFiles() + + gtest := generator.New() + + data, err := proto.Marshal(req) + if err != nil { + g.Error(err, "failed to marshal modified proto") + } + if err := proto.Unmarshal(data, gtest.Request); err != nil { + g.Error(err, "parsing modified proto") + } + + if len(gtest.Request.FileToGenerate) == 0 { + gtest.Fail("no files to generate") + } + + gtest.CommandLineParameters(gtest.Request.GetParameter()) + + // Create a wrapped version of the Descriptors and EnumDescriptors that + // point to the file that defines them. + gtest.WrapTypes() + + gtest.SetPackageNames() + gtest.BuildTypeNameMap() + + gtest.GeneratePlugin(testgen.NewPlugin()) + + for i := 0; i < len(gtest.Response.File); i++ { + if strings.Contains(*gtest.Response.File[i].Content, `//These tests are generated by github.com/gogo/protobuf/plugin/testgen`) { + gtest.Response.File[i].Name = proto.String(strings.Replace(*gtest.Response.File[i].Name, ".pb.go", "pb_test.go", -1)) + g.Response.File = append(g.Response.File, gtest.Response.File[i]) + } + } + + for i := 0; i < len(g.Response.File); i++ { + formatted, err := format.Source([]byte(g.Response.File[i].GetContent())) + if err != nil { + g.Error(err, "go format error") + } + fmts := string(formatted) + g.Response.File[i].Content = &fmts + } + return g.Response +} + +func Write(resp *plugin.CodeGeneratorResponse) { + g := generator.New() + // Send back the results. + data, err := proto.Marshal(resp) + if err != nil { + g.Error(err, "failed to marshal output proto") + } + _, err = os.Stdout.Write(data) + if err != nil { + g.Error(err, "failed to write output proto") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/enum.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/enum.go new file mode 100644 index 0000000000000000000000000000000000000000..f940b989dac54466339e5066303eed89ff64b59e --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/enum.go @@ -0,0 +1,78 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2015, Vastech SA (PTY) LTD. rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 vanity + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + descriptor "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" +) + +func EnumHasBoolExtension(enum *descriptor.EnumDescriptorProto, extension *proto.ExtensionDesc) bool { + if enum.Options == nil { + return false + } + value, err := proto.GetExtension(enum.Options, extension) + if err != nil { + return false + } + if value == nil { + return false + } + if value.(*bool) == nil { + return false + } + return true +} + +func SetBoolEnumOption(extension *proto.ExtensionDesc, value bool) func(enum *descriptor.EnumDescriptorProto) { + return func(enum *descriptor.EnumDescriptorProto) { + if EnumHasBoolExtension(enum, extension) { + return + } + if enum.Options == nil { + enum.Options = &descriptor.EnumOptions{} + } + if err := proto.SetExtension(enum.Options, extension, &value); err != nil { + panic(err) + } + } +} + +func TurnOffGoEnumPrefix(enum *descriptor.EnumDescriptorProto) { + SetBoolEnumOption(gogoproto.E_GoprotoEnumPrefix, false)(enum) +} + +func TurnOffGoEnumStringer(enum *descriptor.EnumDescriptorProto) { + SetBoolEnumOption(gogoproto.E_GoprotoEnumStringer, false)(enum) +} + +func TurnOnEnumStringer(enum *descriptor.EnumDescriptorProto) { + SetBoolEnumOption(gogoproto.E_EnumStringer, true)(enum) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/field.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/field.go new file mode 100644 index 0000000000000000000000000000000000000000..5b499f8985fad440a31811ae803bd85c74a5c171 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/field.go @@ -0,0 +1,83 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2015, Vastech SA (PTY) LTD. rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 vanity + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + descriptor "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" +) + +func FieldHasBoolExtension(field *descriptor.FieldDescriptorProto, extension *proto.ExtensionDesc) bool { + if field.Options == nil { + return false + } + value, err := proto.GetExtension(field.Options, extension) + if err != nil { + return false + } + if value == nil { + return false + } + if value.(*bool) == nil { + return false + } + return true +} + +func SetBoolFieldOption(extension *proto.ExtensionDesc, value bool) func(field *descriptor.FieldDescriptorProto) { + return func(field *descriptor.FieldDescriptorProto) { + if FieldHasBoolExtension(field, extension) { + return + } + if field.Options == nil { + field.Options = &descriptor.FieldOptions{} + } + if err := proto.SetExtension(field.Options, extension, &value); err != nil { + panic(err) + } + } +} + +func TurnOffNullable(field *descriptor.FieldDescriptorProto) { + if field.IsRepeated() && !field.IsMessage() { + return + } + SetBoolFieldOption(gogoproto.E_Nullable, false)(field) +} + +func TurnOffNullableForNativeTypesWithoutDefaultsOnly(field *descriptor.FieldDescriptorProto) { + if field.IsRepeated() || field.IsMessage() { + return + } + if field.DefaultValue != nil { + return + } + SetBoolFieldOption(gogoproto.E_Nullable, false)(field) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/file.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/file.go new file mode 100644 index 0000000000000000000000000000000000000000..cec16afc99e393e0808c92d91fe1f06343e4b27b --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/file.go @@ -0,0 +1,170 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 vanity + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + descriptor "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + "strings" +) + +func NotInPackageGoogleProtobuf(file *descriptor.FileDescriptorProto) bool { + return !strings.HasPrefix(file.GetPackage(), "google.protobuf") +} + +func FilterFiles(files []*descriptor.FileDescriptorProto, f func(file *descriptor.FileDescriptorProto) bool) []*descriptor.FileDescriptorProto { + filtered := make([]*descriptor.FileDescriptorProto, 0, len(files)) + for i := range files { + if !f(files[i]) { + continue + } + filtered = append(filtered, files[i]) + } + return filtered +} + +func FileHasBoolExtension(file *descriptor.FileDescriptorProto, extension *proto.ExtensionDesc) bool { + if file.Options == nil { + return false + } + value, err := proto.GetExtension(file.Options, extension) + if err != nil { + return false + } + if value == nil { + return false + } + if value.(*bool) == nil { + return false + } + return true +} + +func SetBoolFileOption(extension *proto.ExtensionDesc, value bool) func(file *descriptor.FileDescriptorProto) { + return func(file *descriptor.FileDescriptorProto) { + if FileHasBoolExtension(file, extension) { + return + } + if file.Options == nil { + file.Options = &descriptor.FileOptions{} + } + if err := proto.SetExtension(file.Options, extension, &value); err != nil { + panic(err) + } + } +} + +func TurnOffGoGettersAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_GoprotoGettersAll, false)(file) +} + +func TurnOffGoEnumPrefixAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_GoprotoEnumPrefixAll, false)(file) +} + +func TurnOffGoStringerAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_GoprotoStringerAll, false)(file) +} + +func TurnOnVerboseEqualAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_VerboseEqualAll, true)(file) +} + +func TurnOnFaceAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_FaceAll, true)(file) +} + +func TurnOnGoStringAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_GostringAll, true)(file) +} + +func TurnOnPopulateAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_PopulateAll, true)(file) +} + +func TurnOnStringerAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_StringerAll, true)(file) +} + +func TurnOnEqualAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_EqualAll, true)(file) +} + +func TurnOnDescriptionAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_DescriptionAll, true)(file) +} + +func TurnOnTestGenAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_TestgenAll, true)(file) +} + +func TurnOnBenchGenAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_BenchgenAll, true)(file) +} + +func TurnOnMarshalerAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_MarshalerAll, true)(file) +} + +func TurnOnUnmarshalerAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_UnmarshalerAll, true)(file) +} + +func TurnOnSizerAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_SizerAll, true)(file) +} + +func TurnOffGoEnumStringerAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_GoprotoEnumStringerAll, false)(file) +} + +func TurnOnEnumStringerAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_EnumStringerAll, true)(file) +} + +func TurnOnUnsafeUnmarshalerAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_UnsafeUnmarshalerAll, true)(file) +} + +func TurnOnUnsafeMarshalerAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_UnsafeMarshalerAll, true)(file) +} + +func TurnOffGoExtensionsMapAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_GoprotoExtensionsMapAll, false)(file) +} + +func TurnOffGoUnrecognizedAll(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_GoprotoUnrecognizedAll, false)(file) +} + +func TurnOffGogoImport(file *descriptor.FileDescriptorProto) { + SetBoolFileOption(gogoproto.E_GogoprotoImport, false)(file) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/foreach.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/foreach.go new file mode 100644 index 0000000000000000000000000000000000000000..7b054cc38b1974ef92f1040650227b886b1f1571 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/foreach.go @@ -0,0 +1,125 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 vanity + +import descriptor "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" + +func ForEachFile(files []*descriptor.FileDescriptorProto, f func(file *descriptor.FileDescriptorProto)) { + for _, file := range files { + f(file) + } +} + +func OnlyProto2(files []*descriptor.FileDescriptorProto) []*descriptor.FileDescriptorProto { + outs := make([]*descriptor.FileDescriptorProto, 0, len(files)) + for i, file := range files { + if file.GetSyntax() == "proto3" { + continue + } + outs = append(outs, files[i]) + } + return outs +} + +func OnlyProto3(files []*descriptor.FileDescriptorProto) []*descriptor.FileDescriptorProto { + outs := make([]*descriptor.FileDescriptorProto, 0, len(files)) + for i, file := range files { + if file.GetSyntax() != "proto3" { + continue + } + outs = append(outs, files[i]) + } + return outs +} + +func ForEachMessageInFiles(files []*descriptor.FileDescriptorProto, f func(msg *descriptor.DescriptorProto)) { + for _, file := range files { + ForEachMessage(file.MessageType, f) + } +} + +func ForEachMessage(msgs []*descriptor.DescriptorProto, f func(msg *descriptor.DescriptorProto)) { + for _, msg := range msgs { + f(msg) + ForEachMessage(msg.NestedType, f) + } +} + +func ForEachFieldInFilesExcludingExtensions(files []*descriptor.FileDescriptorProto, f func(field *descriptor.FieldDescriptorProto)) { + for _, file := range files { + ForEachFieldExcludingExtensions(file.MessageType, f) + } +} + +func ForEachFieldInFiles(files []*descriptor.FileDescriptorProto, f func(field *descriptor.FieldDescriptorProto)) { + for _, file := range files { + for _, ext := range file.Extension { + f(ext) + } + ForEachField(file.MessageType, f) + } +} + +func ForEachFieldExcludingExtensions(msgs []*descriptor.DescriptorProto, f func(field *descriptor.FieldDescriptorProto)) { + for _, msg := range msgs { + for _, field := range msg.Field { + f(field) + } + ForEachField(msg.NestedType, f) + } +} + +func ForEachField(msgs []*descriptor.DescriptorProto, f func(field *descriptor.FieldDescriptorProto)) { + for _, msg := range msgs { + for _, field := range msg.Field { + f(field) + } + for _, ext := range msg.Extension { + f(ext) + } + ForEachField(msg.NestedType, f) + } +} + +func ForEachEnumInFiles(files []*descriptor.FileDescriptorProto, f func(enum *descriptor.EnumDescriptorProto)) { + for _, file := range files { + for _, enum := range file.EnumType { + f(enum) + } + } +} + +func ForEachEnum(msgs []*descriptor.DescriptorProto, f func(field *descriptor.EnumDescriptorProto)) { + for _, msg := range msgs { + for _, field := range msg.EnumType { + f(field) + } + ForEachEnum(msg.NestedType, f) + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/msg.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/msg.go new file mode 100644 index 0000000000000000000000000000000000000000..a68d995d5ab63495b3a3c4ab9a52859e3a5d8050 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/msg.go @@ -0,0 +1,138 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2015, Vastech SA (PTY) LTD. rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 vanity + +import ( + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/gogoproto" + "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + descriptor "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/protoc-gen-gogo/descriptor" +) + +func MessageHasBoolExtension(msg *descriptor.DescriptorProto, extension *proto.ExtensionDesc) bool { + if msg.Options == nil { + return false + } + value, err := proto.GetExtension(msg.Options, extension) + if err != nil { + return false + } + if value == nil { + return false + } + if value.(*bool) == nil { + return false + } + return true +} + +func SetBoolMessageOption(extension *proto.ExtensionDesc, value bool) func(msg *descriptor.DescriptorProto) { + return func(msg *descriptor.DescriptorProto) { + if MessageHasBoolExtension(msg, extension) { + return + } + if msg.Options == nil { + msg.Options = &descriptor.MessageOptions{} + } + if err := proto.SetExtension(msg.Options, extension, &value); err != nil { + panic(err) + } + } +} + +func TurnOffGoGetters(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_GoprotoGetters, false)(msg) +} + +func TurnOffGoStringer(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_GoprotoStringer, false)(msg) +} + +func TurnOnVerboseEqual(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_VerboseEqual, true)(msg) +} + +func TurnOnFace(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_Face, true)(msg) +} + +func TurnOnGoString(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_Face, true)(msg) +} + +func TurnOnPopulate(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_Populate, true)(msg) +} + +func TurnOnStringer(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_Stringer, true)(msg) +} + +func TurnOnEqual(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_Equal, true)(msg) +} + +func TurnOnDescription(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_Description, true)(msg) +} + +func TurnOnTestGen(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_Testgen, true)(msg) +} + +func TurnOnBenchGen(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_Benchgen, true)(msg) +} + +func TurnOnMarshaler(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_Marshaler, true)(msg) +} + +func TurnOnUnmarshaler(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_Unmarshaler, true)(msg) +} + +func TurnOnSizer(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_Sizer, true)(msg) +} + +func TurnOnUnsafeUnmarshaler(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_UnsafeUnmarshaler, true)(msg) +} + +func TurnOnUnsafeMarshaler(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_UnsafeMarshaler, true)(msg) +} + +func TurnOffGoExtensionsMap(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_GoprotoExtensionsMap, false)(msg) +} + +func TurnOffGoUnrecognized(msg *descriptor.DescriptorProto) { + SetBoolMessageOption(gogoproto.E_GoprotoUnrecognized, false)(msg) +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/Makefile b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..846b74fd91e488052d4c8d8d5d8118c3a878f931 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/Makefile @@ -0,0 +1,18 @@ +regenerate: + go install github.com/gogo/protobuf/protoc-gen-gogofast + protoc --gogofast_out=./fast/ vanity.proto + protoc --proto_path=../../:../../../../../:../../protobuf/:. --gogofast_out=./fast/ gogovanity.proto + protoc-min-version -version="3.0.0" --proto_path=../../:../../../../../:../../protobuf/:. --gogofast_out=./fast/ proto3.proto + go install github.com/gogo/protobuf/protoc-gen-gogofaster + protoc --gogofaster_out=./faster/ vanity.proto + protoc --proto_path=../../:../../../../../:../../protobuf/:. --gogofaster_out=./faster/ gogovanity.proto + protoc-min-version -version="3.0.0" --proto_path=../../:../../../../../:../../protobuf/:. --gogofaster_out=./faster/ proto3.proto + go install github.com/gogo/protobuf/protoc-gen-gogoslick + protoc --gogoslick_out=./slick/ vanity.proto + protoc --proto_path=../../:../../../../../:../../protobuf/:. --gogoslick_out=./slick/ gogovanity.proto + protoc-min-version -version="3.0.0" --proto_path=../../:../../../../../:../../protobuf/:. --gogoslick_out=./slick/ proto3.proto + +test: + go install github.com/gogo/protobuf/protoc-gen-gofast + protoc --gofast_out=./gofast/ vanity.proto + go test ./... diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/doc.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/doc.go new file mode 100644 index 0000000000000000000000000000000000000000..56e54040790227aab12ae1b2f43991b9f00f87f6 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/doc.go @@ -0,0 +1 @@ +package test diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/fast/gogovanity.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/fast/gogovanity.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..725c3ddcc69ba87ee5062bb951b3a6877a6d4f2f --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/fast/gogovanity.pb.go @@ -0,0 +1,383 @@ +// Code generated by protoc-gen-gogo. +// source: gogovanity.proto +// DO NOT EDIT! + +/* + Package vanity is a generated protocol buffer package. + + It is generated from these files: + gogovanity.proto + + It has these top-level messages: + B +*/ +package vanity + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type B struct { + String_ *string `protobuf:"bytes,1,opt,name=String" json:"String,omitempty"` + Int64 *int64 `protobuf:"varint,2,opt,name=Int64" json:"Int64,omitempty"` + Int32 *int32 `protobuf:"varint,3,opt,name=Int32,def=1234" json:"Int32,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *B) Reset() { *m = B{} } +func (m *B) String() string { return proto.CompactTextString(m) } +func (*B) ProtoMessage() {} + +const Default_B_Int32 int32 = 1234 + +func (m *B) GetString_() string { + if m != nil && m.String_ != nil { + return *m.String_ + } + return "" +} + +func (m *B) GetInt64() int64 { + if m != nil && m.Int64 != nil { + return *m.Int64 + } + return 0 +} + +func (m *B) GetInt32() int32 { + if m != nil && m.Int32 != nil { + return *m.Int32 + } + return Default_B_Int32 +} + +func (m *B) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *B) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.String_ != nil { + data[i] = 0xa + i++ + i = encodeVarintGogovanity(data, i, uint64(len(*m.String_))) + i += copy(data[i:], *m.String_) + } + if m.Int64 != nil { + data[i] = 0x10 + i++ + i = encodeVarintGogovanity(data, i, uint64(*m.Int64)) + } + if m.Int32 != nil { + data[i] = 0x18 + i++ + i = encodeVarintGogovanity(data, i, uint64(*m.Int32)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Gogovanity(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Gogovanity(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintGogovanity(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *B) Size() (n int) { + var l int + _ = l + if m.String_ != nil { + l = len(*m.String_) + n += 1 + l + sovGogovanity(uint64(l)) + } + if m.Int64 != nil { + n += 1 + sovGogovanity(uint64(*m.Int64)) + } + if m.Int32 != nil { + n += 1 + sovGogovanity(uint64(*m.Int32)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovGogovanity(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozGogovanity(x uint64) (n int) { + return sovGogovanity(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *B) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGogovanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: B: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: B: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field String_", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGogovanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGogovanity + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.String_ = &s + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int64", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGogovanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Int64 = &v + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGogovanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Int32 = &v + default: + iNdEx = preIndex + skippy, err := skipGogovanity(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthGogovanity + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGogovanity(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGogovanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGogovanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGogovanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthGogovanity + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGogovanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipGogovanity(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthGogovanity = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGogovanity = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/fast/proto3.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/fast/proto3.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..b4fa1b08c5d6ed1e9e6dfe83d49f0d22e47674b0 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/fast/proto3.pb.go @@ -0,0 +1,291 @@ +// Code generated by protoc-gen-gogo. +// source: proto3.proto +// DO NOT EDIT! + +/* +Package vanity is a generated protocol buffer package. + +It is generated from these files: + proto3.proto + +It has these top-level messages: + Aproto3 +*/ +package vanity + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Aproto3 struct { + B string `protobuf:"bytes,1,opt,name=B,proto3" json:"B,omitempty"` +} + +func (m *Aproto3) Reset() { *m = Aproto3{} } +func (m *Aproto3) String() string { return proto.CompactTextString(m) } +func (*Aproto3) ProtoMessage() {} + +func (m *Aproto3) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Aproto3) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.B) > 0 { + data[i] = 0xa + i++ + i = encodeVarintProto3(data, i, uint64(len(m.B))) + i += copy(data[i:], m.B) + } + return i, nil +} + +func encodeFixed64Proto3(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Proto3(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintProto3(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *Aproto3) Size() (n int) { + var l int + _ = l + l = len(m.B) + if l > 0 { + n += 1 + l + sovProto3(uint64(l)) + } + return n +} + +func sovProto3(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozProto3(x uint64) (n int) { + return sovProto3(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Aproto3) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Aproto3: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Aproto3: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthProto3 + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.B = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipProto3(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthProto3 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipProto3(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthProto3 + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipProto3(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthProto3 = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowProto3 = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/fast/vanity.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/fast/vanity.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..48a9d9844334e3cf858c9c1de314e01b6b22c569 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/fast/vanity.pb.go @@ -0,0 +1,352 @@ +// Code generated by protoc-gen-gogo. +// source: vanity.proto +// DO NOT EDIT! + +/* + Package vanity is a generated protocol buffer package. + + It is generated from these files: + vanity.proto + + It has these top-level messages: + A +*/ +package vanity + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type A struct { + Strings *string `protobuf:"bytes,1,opt,name=Strings" json:"Strings,omitempty"` + Int *int64 `protobuf:"varint,2,req,name=Int" json:"Int,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *A) Reset() { *m = A{} } +func (m *A) String() string { return proto.CompactTextString(m) } +func (*A) ProtoMessage() {} + +func (m *A) GetStrings() string { + if m != nil && m.Strings != nil { + return *m.Strings + } + return "" +} + +func (m *A) GetInt() int64 { + if m != nil && m.Int != nil { + return *m.Int + } + return 0 +} + +func (m *A) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *A) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Strings != nil { + data[i] = 0xa + i++ + i = encodeVarintVanity(data, i, uint64(len(*m.Strings))) + i += copy(data[i:], *m.Strings) + } + if m.Int == nil { + return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Int") + } else { + data[i] = 0x10 + i++ + i = encodeVarintVanity(data, i, uint64(*m.Int)) + } + if m.XXX_unrecognized != nil { + i += copy(data[i:], m.XXX_unrecognized) + } + return i, nil +} + +func encodeFixed64Vanity(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Vanity(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintVanity(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *A) Size() (n int) { + var l int + _ = l + if m.Strings != nil { + l = len(*m.Strings) + n += 1 + l + sovVanity(uint64(l)) + } + if m.Int != nil { + n += 1 + sovVanity(uint64(*m.Int)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovVanity(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozVanity(x uint64) (n int) { + return sovVanity(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *A) Unmarshal(data []byte) error { + var hasFields [1]uint64 + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: A: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: A: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Strings", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthVanity + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.Strings = &s + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Int = &v + hasFields[0] |= uint64(0x00000001) + default: + iNdEx = preIndex + skippy, err := skipVanity(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthVanity + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, data[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + if hasFields[0]&uint64(0x00000001) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Int") + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipVanity(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthVanity + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipVanity(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthVanity = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowVanity = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/faster/gogovanity.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/faster/gogovanity.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..bddc153c865c1e71357ee1b84554a2fed6ede7d7 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/faster/gogovanity.pb.go @@ -0,0 +1,370 @@ +// Code generated by protoc-gen-gogo. +// source: gogovanity.proto +// DO NOT EDIT! + +/* + Package vanity is a generated protocol buffer package. + + It is generated from these files: + gogovanity.proto + + It has these top-level messages: + B +*/ +package vanity + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type B struct { + String_ *string `protobuf:"bytes,1,opt,name=String" json:"String,omitempty"` + Int64 int64 `protobuf:"varint,2,opt,name=Int64" json:"Int64"` + Int32 *int32 `protobuf:"varint,3,opt,name=Int32,def=1234" json:"Int32,omitempty"` +} + +func (m *B) Reset() { *m = B{} } +func (m *B) String() string { return proto.CompactTextString(m) } +func (*B) ProtoMessage() {} + +const Default_B_Int32 int32 = 1234 + +func (m *B) GetString_() string { + if m != nil && m.String_ != nil { + return *m.String_ + } + return "" +} + +func (m *B) GetInt64() int64 { + if m != nil { + return m.Int64 + } + return 0 +} + +func (m *B) GetInt32() int32 { + if m != nil && m.Int32 != nil { + return *m.Int32 + } + return Default_B_Int32 +} + +func (m *B) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *B) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.String_ != nil { + data[i] = 0xa + i++ + i = encodeVarintGogovanity(data, i, uint64(len(*m.String_))) + i += copy(data[i:], *m.String_) + } + data[i] = 0x10 + i++ + i = encodeVarintGogovanity(data, i, uint64(m.Int64)) + if m.Int32 != nil { + data[i] = 0x18 + i++ + i = encodeVarintGogovanity(data, i, uint64(*m.Int32)) + } + return i, nil +} + +func encodeFixed64Gogovanity(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Gogovanity(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintGogovanity(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *B) Size() (n int) { + var l int + _ = l + if m.String_ != nil { + l = len(*m.String_) + n += 1 + l + sovGogovanity(uint64(l)) + } + n += 1 + sovGogovanity(uint64(m.Int64)) + if m.Int32 != nil { + n += 1 + sovGogovanity(uint64(*m.Int32)) + } + return n +} + +func sovGogovanity(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozGogovanity(x uint64) (n int) { + return sovGogovanity(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *B) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGogovanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: B: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: B: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field String_", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGogovanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGogovanity + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.String_ = &s + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int64", wireType) + } + m.Int64 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGogovanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Int64 |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGogovanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Int32 = &v + default: + iNdEx = preIndex + skippy, err := skipGogovanity(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthGogovanity + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGogovanity(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGogovanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGogovanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGogovanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthGogovanity + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGogovanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipGogovanity(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthGogovanity = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGogovanity = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/faster/proto3.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/faster/proto3.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..b4fa1b08c5d6ed1e9e6dfe83d49f0d22e47674b0 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/faster/proto3.pb.go @@ -0,0 +1,291 @@ +// Code generated by protoc-gen-gogo. +// source: proto3.proto +// DO NOT EDIT! + +/* +Package vanity is a generated protocol buffer package. + +It is generated from these files: + proto3.proto + +It has these top-level messages: + Aproto3 +*/ +package vanity + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Aproto3 struct { + B string `protobuf:"bytes,1,opt,name=B,proto3" json:"B,omitempty"` +} + +func (m *Aproto3) Reset() { *m = Aproto3{} } +func (m *Aproto3) String() string { return proto.CompactTextString(m) } +func (*Aproto3) ProtoMessage() {} + +func (m *Aproto3) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Aproto3) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.B) > 0 { + data[i] = 0xa + i++ + i = encodeVarintProto3(data, i, uint64(len(m.B))) + i += copy(data[i:], m.B) + } + return i, nil +} + +func encodeFixed64Proto3(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Proto3(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintProto3(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *Aproto3) Size() (n int) { + var l int + _ = l + l = len(m.B) + if l > 0 { + n += 1 + l + sovProto3(uint64(l)) + } + return n +} + +func sovProto3(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozProto3(x uint64) (n int) { + return sovProto3(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Aproto3) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Aproto3: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Aproto3: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthProto3 + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.B = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipProto3(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthProto3 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipProto3(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthProto3 + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipProto3(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthProto3 = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowProto3 = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/faster/vanity.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/faster/vanity.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..47eea066c07f7b5149dec5c47758e17054248c81 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/faster/vanity.pb.go @@ -0,0 +1,331 @@ +// Code generated by protoc-gen-gogo. +// source: vanity.proto +// DO NOT EDIT! + +/* + Package vanity is a generated protocol buffer package. + + It is generated from these files: + vanity.proto + + It has these top-level messages: + A +*/ +package vanity + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +import io "io" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type A struct { + Strings string `protobuf:"bytes,1,opt,name=Strings" json:"Strings"` + Int int64 `protobuf:"varint,2,req,name=Int" json:"Int"` +} + +func (m *A) Reset() { *m = A{} } +func (m *A) String() string { return proto.CompactTextString(m) } +func (*A) ProtoMessage() {} + +func (m *A) GetStrings() string { + if m != nil { + return m.Strings + } + return "" +} + +func (m *A) GetInt() int64 { + if m != nil { + return m.Int + } + return 0 +} + +func (m *A) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *A) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintVanity(data, i, uint64(len(m.Strings))) + i += copy(data[i:], m.Strings) + data[i] = 0x10 + i++ + i = encodeVarintVanity(data, i, uint64(m.Int)) + return i, nil +} + +func encodeFixed64Vanity(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Vanity(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintVanity(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *A) Size() (n int) { + var l int + _ = l + l = len(m.Strings) + n += 1 + l + sovVanity(uint64(l)) + n += 1 + sovVanity(uint64(m.Int)) + return n +} + +func sovVanity(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozVanity(x uint64) (n int) { + return sovVanity(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *A) Unmarshal(data []byte) error { + var hasFields [1]uint64 + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: A: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: A: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Strings", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthVanity + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Strings = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int", wireType) + } + m.Int = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Int |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + hasFields[0] |= uint64(0x00000001) + default: + iNdEx = preIndex + skippy, err := skipVanity(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthVanity + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + if hasFields[0]&uint64(0x00000001) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Int") + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipVanity(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthVanity + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipVanity(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthVanity = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowVanity = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/gofast/.gitignore b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/gofast/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..9b0b440dc050b16d9b21f468e5e73687e84766b1 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/gofast/.gitignore @@ -0,0 +1 @@ +*.pb.go \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/gogovanity.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/gogovanity.proto new file mode 100644 index 0000000000000000000000000000000000000000..5d75ec6b0d49b9e4fb111826bfc0a0aac3942332 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/gogovanity.proto @@ -0,0 +1,37 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package vanity; + +import "github.com/gogo/protobuf/gogoproto/gogo.proto"; + +message B { + optional string String = 1 [(gogoproto.nullable) = true]; + optional int64 Int64 = 2; + optional int32 Int32 = 3 [default = 1234]; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/proto3.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/proto3.proto new file mode 100644 index 0000000000000000000000000000000000000000..429b6fda11059dd345a3c1984f4292f792f976e8 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/proto3.proto @@ -0,0 +1,33 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 vanity; + +message Aproto3 { + string B = 1; +} \ No newline at end of file diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/slick/gogovanity.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/slick/gogovanity.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..c7725db8c6b4161caa1a075fb564c7c3c55f1fab --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/slick/gogovanity.pb.go @@ -0,0 +1,479 @@ +// Code generated by protoc-gen-gogo. +// source: gogovanity.proto +// DO NOT EDIT! + +/* + Package vanity is a generated protocol buffer package. + + It is generated from these files: + gogovanity.proto + + It has these top-level messages: + B +*/ +package vanity + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type B struct { + String_ *string `protobuf:"bytes,1,opt,name=String" json:"String,omitempty"` + Int64 int64 `protobuf:"varint,2,opt,name=Int64" json:"Int64"` + Int32 *int32 `protobuf:"varint,3,opt,name=Int32,def=1234" json:"Int32,omitempty"` +} + +func (m *B) Reset() { *m = B{} } +func (*B) ProtoMessage() {} + +const Default_B_Int32 int32 = 1234 + +func (m *B) GetString_() string { + if m != nil && m.String_ != nil { + return *m.String_ + } + return "" +} + +func (m *B) GetInt64() int64 { + if m != nil { + return m.Int64 + } + return 0 +} + +func (m *B) GetInt32() int32 { + if m != nil && m.Int32 != nil { + return *m.Int32 + } + return Default_B_Int32 +} + +func (this *B) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*B) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.String_ != nil && that1.String_ != nil { + if *this.String_ != *that1.String_ { + return false + } + } else if this.String_ != nil { + return false + } else if that1.String_ != nil { + return false + } + if this.Int64 != that1.Int64 { + return false + } + if this.Int32 != nil && that1.Int32 != nil { + if *this.Int32 != *that1.Int32 { + return false + } + } else if this.Int32 != nil { + return false + } else if that1.Int32 != nil { + return false + } + return true +} +func (this *B) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&vanity.B{") + if this.String_ != nil { + s = append(s, "String_: "+valueToGoStringGogovanity(this.String_, "string")+",\n") + } + s = append(s, "Int64: "+fmt.Sprintf("%#v", this.Int64)+",\n") + if this.Int32 != nil { + s = append(s, "Int32: "+valueToGoStringGogovanity(this.Int32, "int32")+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringGogovanity(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringGogovanity(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *B) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *B) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.String_ != nil { + data[i] = 0xa + i++ + i = encodeVarintGogovanity(data, i, uint64(len(*m.String_))) + i += copy(data[i:], *m.String_) + } + data[i] = 0x10 + i++ + i = encodeVarintGogovanity(data, i, uint64(m.Int64)) + if m.Int32 != nil { + data[i] = 0x18 + i++ + i = encodeVarintGogovanity(data, i, uint64(*m.Int32)) + } + return i, nil +} + +func encodeFixed64Gogovanity(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Gogovanity(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintGogovanity(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *B) Size() (n int) { + var l int + _ = l + if m.String_ != nil { + l = len(*m.String_) + n += 1 + l + sovGogovanity(uint64(l)) + } + n += 1 + sovGogovanity(uint64(m.Int64)) + if m.Int32 != nil { + n += 1 + sovGogovanity(uint64(*m.Int32)) + } + return n +} + +func sovGogovanity(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozGogovanity(x uint64) (n int) { + return sovGogovanity(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *B) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&B{`, + `String_:` + valueToStringGogovanity(this.String_) + `,`, + `Int64:` + fmt.Sprintf("%v", this.Int64) + `,`, + `Int32:` + valueToStringGogovanity(this.Int32) + `,`, + `}`, + }, "") + return s +} +func valueToStringGogovanity(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *B) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGogovanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: B: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: B: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field String_", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGogovanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGogovanity + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + s := string(data[iNdEx:postIndex]) + m.String_ = &s + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int64", wireType) + } + m.Int64 = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGogovanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Int64 |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int32", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGogovanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Int32 = &v + default: + iNdEx = preIndex + skippy, err := skipGogovanity(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthGogovanity + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGogovanity(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGogovanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGogovanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGogovanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthGogovanity + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGogovanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipGogovanity(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthGogovanity = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGogovanity = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/slick/proto3.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/slick/proto3.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..689b31a7e311e1c32e86b13b33380357a5cb04a7 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/slick/proto3.pb.go @@ -0,0 +1,374 @@ +// Code generated by protoc-gen-gogo. +// source: proto3.proto +// DO NOT EDIT! + +/* +Package vanity is a generated protocol buffer package. + +It is generated from these files: + proto3.proto + +It has these top-level messages: + Aproto3 +*/ +package vanity + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type Aproto3 struct { + B string `protobuf:"bytes,1,opt,name=B,proto3" json:"B,omitempty"` +} + +func (m *Aproto3) Reset() { *m = Aproto3{} } +func (*Aproto3) ProtoMessage() {} + +func (this *Aproto3) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*Aproto3) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.B != that1.B { + return false + } + return true +} +func (this *Aproto3) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 5) + s = append(s, "&vanity.Aproto3{") + s = append(s, "B: "+fmt.Sprintf("%#v", this.B)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringProto3(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringProto3(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *Aproto3) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *Aproto3) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.B) > 0 { + data[i] = 0xa + i++ + i = encodeVarintProto3(data, i, uint64(len(m.B))) + i += copy(data[i:], m.B) + } + return i, nil +} + +func encodeFixed64Proto3(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Proto3(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintProto3(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *Aproto3) Size() (n int) { + var l int + _ = l + l = len(m.B) + if l > 0 { + n += 1 + l + sovProto3(uint64(l)) + } + return n +} + +func sovProto3(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozProto3(x uint64) (n int) { + return sovProto3(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *Aproto3) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&Aproto3{`, + `B:` + fmt.Sprintf("%v", this.B) + `,`, + `}`, + }, "") + return s +} +func valueToStringProto3(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *Aproto3) Unmarshal(data []byte) error { + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Aproto3: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Aproto3: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field B", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProto3 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthProto3 + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.B = string(data[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipProto3(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthProto3 + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipProto3(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthProto3 + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowProto3 + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipProto3(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthProto3 = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowProto3 = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/slick/vanity.pb.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/slick/vanity.pb.go new file mode 100644 index 0000000000000000000000000000000000000000..ae9327338d366f011b0628f7d1ae6b86f2004529 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/slick/vanity.pb.go @@ -0,0 +1,418 @@ +// Code generated by protoc-gen-gogo. +// source: vanity.proto +// DO NOT EDIT! + +/* + Package vanity is a generated protocol buffer package. + + It is generated from these files: + vanity.proto + + It has these top-level messages: + A +*/ +package vanity + +import proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import fmt "fmt" +import math "math" + +import strings "strings" +import github_com_gogo_protobuf_proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" +import sort "sort" +import strconv "strconv" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type A struct { + Strings string `protobuf:"bytes,1,opt,name=Strings" json:"Strings"` + Int int64 `protobuf:"varint,2,req,name=Int" json:"Int"` +} + +func (m *A) Reset() { *m = A{} } +func (*A) ProtoMessage() {} + +func (m *A) GetStrings() string { + if m != nil { + return m.Strings + } + return "" +} + +func (m *A) GetInt() int64 { + if m != nil { + return m.Int + } + return 0 +} + +func (this *A) Equal(that interface{}) bool { + if that == nil { + if this == nil { + return true + } + return false + } + + that1, ok := that.(*A) + if !ok { + return false + } + if that1 == nil { + if this == nil { + return true + } + return false + } else if this == nil { + return false + } + if this.Strings != that1.Strings { + return false + } + if this.Int != that1.Int { + return false + } + return true +} +func (this *A) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&vanity.A{") + s = append(s, "Strings: "+fmt.Sprintf("%#v", this.Strings)+",\n") + s = append(s, "Int: "+fmt.Sprintf("%#v", this.Int)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringVanity(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func extensionToGoStringVanity(e map[int32]github_com_gogo_protobuf_proto.Extension) string { + if e == nil { + return "nil" + } + s := "map[int32]proto.Extension{" + keys := make([]int, 0, len(e)) + for k := range e { + keys = append(keys, int(k)) + } + sort.Ints(keys) + ss := []string{} + for _, k := range keys { + ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString()) + } + s += strings.Join(ss, ",") + "}" + return s +} +func (m *A) Marshal() (data []byte, err error) { + size := m.Size() + data = make([]byte, size) + n, err := m.MarshalTo(data) + if err != nil { + return nil, err + } + return data[:n], nil +} + +func (m *A) MarshalTo(data []byte) (int, error) { + var i int + _ = i + var l int + _ = l + data[i] = 0xa + i++ + i = encodeVarintVanity(data, i, uint64(len(m.Strings))) + i += copy(data[i:], m.Strings) + data[i] = 0x10 + i++ + i = encodeVarintVanity(data, i, uint64(m.Int)) + return i, nil +} + +func encodeFixed64Vanity(data []byte, offset int, v uint64) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + data[offset+4] = uint8(v >> 32) + data[offset+5] = uint8(v >> 40) + data[offset+6] = uint8(v >> 48) + data[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Vanity(data []byte, offset int, v uint32) int { + data[offset] = uint8(v) + data[offset+1] = uint8(v >> 8) + data[offset+2] = uint8(v >> 16) + data[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintVanity(data []byte, offset int, v uint64) int { + for v >= 1<<7 { + data[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + data[offset] = uint8(v) + return offset + 1 +} +func (m *A) Size() (n int) { + var l int + _ = l + l = len(m.Strings) + n += 1 + l + sovVanity(uint64(l)) + n += 1 + sovVanity(uint64(m.Int)) + return n +} + +func sovVanity(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozVanity(x uint64) (n int) { + return sovVanity(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *A) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&A{`, + `Strings:` + fmt.Sprintf("%v", this.Strings) + `,`, + `Int:` + fmt.Sprintf("%v", this.Int) + `,`, + `}`, + }, "") + return s +} +func valueToStringVanity(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *A) Unmarshal(data []byte) error { + var hasFields [1]uint64 + l := len(data) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: A: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: A: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Strings", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthVanity + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Strings = string(data[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Int", wireType) + } + m.Int = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowVanity + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + m.Int |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + hasFields[0] |= uint64(0x00000001) + default: + iNdEx = preIndex + skippy, err := skipVanity(data[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthVanity + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + if hasFields[0]&uint64(0x00000001) == 0 { + return github_com_gogo_protobuf_proto.NewRequiredNotSetError("Int") + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipVanity(data []byte) (n int, err error) { + l := len(data) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if data[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthVanity + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowVanity + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := data[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipVanity(data[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthVanity = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowVanity = fmt.Errorf("proto: integer overflow") +) diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/vanity.proto b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/vanity.proto new file mode 100644 index 0000000000000000000000000000000000000000..08115380699ae3b5975493129b01fc52e4f425c4 --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/vanity.proto @@ -0,0 +1,34 @@ +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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"; + +package vanity; + +message A { + optional string Strings = 1; + required int64 Int = 2; +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/vanity_test.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/vanity_test.go new file mode 100644 index 0000000000000000000000000000000000000000..378f0cf2dc1bc105f2540be1b1e34593eed3d56c --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/vanity_test.go @@ -0,0 +1,93 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2015, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 test + +import ( + fast "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/fast" + faster "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/faster" + slick "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/vanity/test/slick" + "testing" +) + +func TestFast(t *testing.T) { + _ = (&fast.A{}).Marshal + _ = (&fast.A{}).MarshalTo + _ = (&fast.A{}).Unmarshal + _ = (&fast.A{}).Size + + _ = (&fast.B{}).Marshal + _ = (&fast.B{}).MarshalTo + _ = (&fast.B{}).Unmarshal + _ = (&fast.B{}).Size +} + +func TestFaster(t *testing.T) { + _ = (&faster.A{}).Marshal + _ = (&faster.A{}).MarshalTo + _ = (&faster.A{}).Unmarshal + _ = (&faster.A{}).Size + + _ = (&faster.A{}).Strings == "" + + _ = (&faster.B{}).Marshal + _ = (&faster.B{}).MarshalTo + _ = (&faster.B{}).Unmarshal + _ = (&faster.B{}).Size + + _ = (&faster.B{}).String_ == nil + _ = (&faster.B{}).Int64 == 0 + _ = (&faster.B{}).Int32 == nil + if (&faster.B{}).GetInt32() != 1234 { + t.Fatalf("expected default") + } +} + +func TestSlick(t *testing.T) { + _ = (&slick.A{}).Marshal + _ = (&slick.A{}).MarshalTo + _ = (&slick.A{}).Unmarshal + _ = (&slick.A{}).Size + + _ = (&slick.A{}).Strings == "" + + _ = (&slick.A{}).GoString + _ = (&slick.A{}).String + + _ = (&slick.B{}).Marshal + _ = (&slick.B{}).MarshalTo + _ = (&slick.B{}).Unmarshal + _ = (&slick.B{}).Size + + _ = (&slick.B{}).String_ == nil + _ = (&slick.B{}).Int64 == 0 + _ = (&slick.B{}).Int32 == nil + if (&slick.B{}).GetInt32() != 1234 { + t.Fatalf("expected default") + } +} diff --git a/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/version/version.go b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/version/version.go new file mode 100644 index 0000000000000000000000000000000000000000..05c49b40b23a384bf535d40bcdc8c1be5dc8da6f --- /dev/null +++ b/vendor/QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/version/version.go @@ -0,0 +1,78 @@ +// Extensions for Protocol Buffers to create more go like structures. +// +// Copyright (c) 2013, Vastech SA (PTY) LTD. All rights reserved. +// http://github.com/gogo/protobuf/gogoproto +// +// 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. +// +// 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 version + +import ( + "fmt" + "os/exec" + "strconv" + "strings" +) + +func Get() string { + versionBytes, _ := exec.Command("protoc", "--version").CombinedOutput() + version := strings.TrimSpace(string(versionBytes)) + versions := strings.Split(version, " ") + if len(versions) != 2 { + panic("version string returned from protoc is seperated with a space: " + version) + } + return versions[1] +} + +func parseVersion(version string) (int, error) { + versions := strings.Split(version, ".") + if len(versions) != 3 { + return 0, fmt.Errorf("version does not have 3 numbers seperated by dots: %s", version) + } + n := 0 + for _, v := range versions { + i, err := strconv.Atoi(v) + if err != nil { + return 0, err + } + n = n*10 + i + } + return n, nil +} + +func less(this, that string) bool { + thisNum, err := parseVersion(this) + if err != nil { + panic(err) + } + thatNum, err := parseVersion(that) + if err != nil { + panic(err) + } + return thisNum <= thatNum +} + +func AtLeast(v string) bool { + return less(v, Get()) +}